PolarSSL v1.2.5
test_suite_gcm.decrypt.c
Go to the documentation of this file.
1 #include "fct.h"
2 
3 #include <polarssl/gcm.h>
4 
5 #include <polarssl/config.h>
6 
7 #ifdef _MSC_VER
8 #include <basetsd.h>
9 typedef UINT32 uint32_t;
10 #else
11 #include <inttypes.h>
12 #endif
13 
14 /*
15  * 32-bit integer manipulation macros (big endian)
16  */
17 #ifndef GET_UINT32_BE
18 #define GET_UINT32_BE(n,b,i) \
19 { \
20  (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
21  | ( (uint32_t) (b)[(i) + 1] << 16 ) \
22  | ( (uint32_t) (b)[(i) + 2] << 8 ) \
23  | ( (uint32_t) (b)[(i) + 3] ); \
24 }
25 #endif
26 
27 #ifndef PUT_UINT32_BE
28 #define PUT_UINT32_BE(n,b,i) \
29 { \
30  (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
31  (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
32  (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
33  (b)[(i) + 3] = (unsigned char) ( (n) ); \
34 }
35 #endif
36 
37 int unhexify(unsigned char *obuf, const char *ibuf)
38 {
39  unsigned char c, c2;
40  int len = strlen(ibuf) / 2;
41  assert(!(strlen(ibuf) %1)); // must be even number of bytes
42 
43  while (*ibuf != 0)
44  {
45  c = *ibuf++;
46  if( c >= '0' && c <= '9' )
47  c -= '0';
48  else if( c >= 'a' && c <= 'f' )
49  c -= 'a' - 10;
50  else if( c >= 'A' && c <= 'F' )
51  c -= 'A' - 10;
52  else
53  assert( 0 );
54 
55  c2 = *ibuf++;
56  if( c2 >= '0' && c2 <= '9' )
57  c2 -= '0';
58  else if( c2 >= 'a' && c2 <= 'f' )
59  c2 -= 'a' - 10;
60  else if( c2 >= 'A' && c2 <= 'F' )
61  c2 -= 'A' - 10;
62  else
63  assert( 0 );
64 
65  *obuf++ = ( c << 4 ) | c2;
66  }
67 
68  return len;
69 }
70 
71 void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
72 {
73  unsigned char l, h;
74 
75  while (len != 0)
76  {
77  h = (*ibuf) / 16;
78  l = (*ibuf) % 16;
79 
80  if( h < 10 )
81  *obuf++ = '0' + h;
82  else
83  *obuf++ = 'a' + h - 10;
84 
85  if( l < 10 )
86  *obuf++ = '0' + l;
87  else
88  *obuf++ = 'a' + l - 10;
89 
90  ++ibuf;
91  len--;
92  }
93 }
94 
104 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
105 {
106  size_t i;
107 
108  if( rng_state != NULL )
109  rng_state = NULL;
110 
111  for( i = 0; i < len; ++i )
112  output[i] = rand();
113 
114  return( 0 );
115 }
116 
122 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
123 {
124  if( rng_state != NULL )
125  rng_state = NULL;
126 
127  memset( output, 0, len );
128 
129  return( 0 );
130 }
131 
132 typedef struct
133 {
134  unsigned char *buf;
135  size_t length;
136 } rnd_buf_info;
137 
149 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
150 {
151  rnd_buf_info *info = (rnd_buf_info *) rng_state;
152  size_t use_len;
153 
154  if( rng_state == NULL )
155  return( rnd_std_rand( NULL, output, len ) );
156 
157  use_len = len;
158  if( len > info->length )
159  use_len = info->length;
160 
161  if( use_len )
162  {
163  memcpy( output, info->buf, use_len );
164  info->buf += use_len;
165  info->length -= use_len;
166  }
167 
168  if( len - use_len > 0 )
169  return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
170 
171  return( 0 );
172 }
173 
181 typedef struct
182 {
183  uint32_t key[16];
184  uint32_t v0, v1;
186 
195 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
196 {
197  rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
198  uint32_t i, *k, sum, delta=0x9E3779B9;
199  unsigned char result[4];
200 
201  if( rng_state == NULL )
202  return( rnd_std_rand( NULL, output, len ) );
203 
204  k = info->key;
205 
206  while( len > 0 )
207  {
208  size_t use_len = ( len > 4 ) ? 4 : len;
209  sum = 0;
210 
211  for( i = 0; i < 32; i++ )
212  {
213  info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
214  sum += delta;
215  info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
216  }
217 
218  PUT_UINT32_BE( info->v0, result, 0 );
219  memcpy( output, result, use_len );
220  len -= use_len;
221  }
222 
223  return( 0 );
224 }
225 
226 
228 {
229 #ifdef POLARSSL_GCM_C
230 
231 
232  FCT_SUITE_BGN(test_suite_gcm)
233  {
234 
235  FCT_TEST_BGN(gcm_nist_validation_aes_12812800128_0)
236  {
237  unsigned char key_str[128];
238  unsigned char src_str[128];
239  unsigned char dst_str[257];
240  unsigned char iv_str[128];
241  unsigned char add_str[128];
242  unsigned char tag_str[128];
243  unsigned char output[128];
244  gcm_context ctx;
245  unsigned int key_len;
246  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
247  int ret;
248 
249  memset(key_str, 0x00, 128);
250  memset(src_str, 0x00, 128);
251  memset(dst_str, 0x00, 257);
252  memset(iv_str, 0x00, 128);
253  memset(add_str, 0x00, 128);
254  memset(tag_str, 0x00, 128);
255  memset(output, 0x00, 128);
256 
257  key_len = unhexify( key_str, "d785dafea3e966731ef6fc6202262584" );
258  pt_len = unhexify( src_str, "" );
259  iv_len = unhexify( iv_str, "d91a46205ee94058b3b8403997592dd2" );
260  add_len = unhexify( add_str, "" );
261  unhexify( tag_str, "3b92a17c1b9c3578a68cffea5a5b6245" );
262 
263  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
264  if( 0 == 0 )
265  {
266  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
267 
268  if( strcmp( "FAIL", "" ) == 0 )
269  {
270  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
271  }
272  else
273  {
274  hexify( dst_str, output, pt_len );
275 
276  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
277  }
278  }
279  }
280  FCT_TEST_END();
281 
282 
283  FCT_TEST_BGN(gcm_nist_validation_aes_12812800128_1)
284  {
285  unsigned char key_str[128];
286  unsigned char src_str[128];
287  unsigned char dst_str[257];
288  unsigned char iv_str[128];
289  unsigned char add_str[128];
290  unsigned char tag_str[128];
291  unsigned char output[128];
292  gcm_context ctx;
293  unsigned int key_len;
294  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
295  int ret;
296 
297  memset(key_str, 0x00, 128);
298  memset(src_str, 0x00, 128);
299  memset(dst_str, 0x00, 257);
300  memset(iv_str, 0x00, 128);
301  memset(add_str, 0x00, 128);
302  memset(tag_str, 0x00, 128);
303  memset(output, 0x00, 128);
304 
305  key_len = unhexify( key_str, "aec963833b9098de1ababc853ab74d96" );
306  pt_len = unhexify( src_str, "" );
307  iv_len = unhexify( iv_str, "4e0ffd93beffd732c6f7d6ad606a2d24" );
308  add_len = unhexify( add_str, "" );
309  unhexify( tag_str, "e9fcedc176dfe587dc61b2011010cdf1" );
310 
311  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
312  if( 0 == 0 )
313  {
314  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
315 
316  if( strcmp( "FAIL", "" ) == 0 )
317  {
318  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
319  }
320  else
321  {
322  hexify( dst_str, output, pt_len );
323 
324  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
325  }
326  }
327  }
328  FCT_TEST_END();
329 
330 
331  FCT_TEST_BGN(gcm_nist_validation_aes_12812800128_2)
332  {
333  unsigned char key_str[128];
334  unsigned char src_str[128];
335  unsigned char dst_str[257];
336  unsigned char iv_str[128];
337  unsigned char add_str[128];
338  unsigned char tag_str[128];
339  unsigned char output[128];
340  gcm_context ctx;
341  unsigned int key_len;
342  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
343  int ret;
344 
345  memset(key_str, 0x00, 128);
346  memset(src_str, 0x00, 128);
347  memset(dst_str, 0x00, 257);
348  memset(iv_str, 0x00, 128);
349  memset(add_str, 0x00, 128);
350  memset(tag_str, 0x00, 128);
351  memset(output, 0x00, 128);
352 
353  key_len = unhexify( key_str, "c4fb9e3393681da9cec5ec96f87c5c31" );
354  pt_len = unhexify( src_str, "" );
355  iv_len = unhexify( iv_str, "845e910bc055d895879f62101d08b4c7" );
356  add_len = unhexify( add_str, "" );
357  unhexify( tag_str, "99fb783c497416e4b6e2a5de7c782057" );
358 
359  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
360  if( 0 == 0 )
361  {
362  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
363 
364  if( strcmp( "FAIL", "FAIL" ) == 0 )
365  {
366  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
367  }
368  else
369  {
370  hexify( dst_str, output, pt_len );
371 
372  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
373  }
374  }
375  }
376  FCT_TEST_END();
377 
378 
379  FCT_TEST_BGN(gcm_nist_validation_aes_12812800120_0)
380  {
381  unsigned char key_str[128];
382  unsigned char src_str[128];
383  unsigned char dst_str[257];
384  unsigned char iv_str[128];
385  unsigned char add_str[128];
386  unsigned char tag_str[128];
387  unsigned char output[128];
388  gcm_context ctx;
389  unsigned int key_len;
390  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
391  int ret;
392 
393  memset(key_str, 0x00, 128);
394  memset(src_str, 0x00, 128);
395  memset(dst_str, 0x00, 257);
396  memset(iv_str, 0x00, 128);
397  memset(add_str, 0x00, 128);
398  memset(tag_str, 0x00, 128);
399  memset(output, 0x00, 128);
400 
401  key_len = unhexify( key_str, "2a930f2e09beceacd9919cb76f2ac8d3" );
402  pt_len = unhexify( src_str, "" );
403  iv_len = unhexify( iv_str, "340d9af44f6370eff534c653033a785a" );
404  add_len = unhexify( add_str, "" );
405  unhexify( tag_str, "0c1e5e9c8fe5edfd11f114f3503d63" );
406 
407  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
408  if( 0 == 0 )
409  {
410  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
411 
412  if( strcmp( "FAIL", "" ) == 0 )
413  {
414  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
415  }
416  else
417  {
418  hexify( dst_str, output, pt_len );
419 
420  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
421  }
422  }
423  }
424  FCT_TEST_END();
425 
426 
427  FCT_TEST_BGN(gcm_nist_validation_aes_12812800120_1)
428  {
429  unsigned char key_str[128];
430  unsigned char src_str[128];
431  unsigned char dst_str[257];
432  unsigned char iv_str[128];
433  unsigned char add_str[128];
434  unsigned char tag_str[128];
435  unsigned char output[128];
436  gcm_context ctx;
437  unsigned int key_len;
438  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
439  int ret;
440 
441  memset(key_str, 0x00, 128);
442  memset(src_str, 0x00, 128);
443  memset(dst_str, 0x00, 257);
444  memset(iv_str, 0x00, 128);
445  memset(add_str, 0x00, 128);
446  memset(tag_str, 0x00, 128);
447  memset(output, 0x00, 128);
448 
449  key_len = unhexify( key_str, "fe71177e02073b1c407b5724e2263a5e" );
450  pt_len = unhexify( src_str, "" );
451  iv_len = unhexify( iv_str, "83c23d20d2a9d4b8f92da96587c96b18" );
452  add_len = unhexify( add_str, "" );
453  unhexify( tag_str, "43b2ca795420f35f6cb39f5dfa47a2" );
454 
455  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
456  if( 0 == 0 )
457  {
458  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
459 
460  if( strcmp( "FAIL", "" ) == 0 )
461  {
462  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
463  }
464  else
465  {
466  hexify( dst_str, output, pt_len );
467 
468  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
469  }
470  }
471  }
472  FCT_TEST_END();
473 
474 
475  FCT_TEST_BGN(gcm_nist_validation_aes_12812800120_2)
476  {
477  unsigned char key_str[128];
478  unsigned char src_str[128];
479  unsigned char dst_str[257];
480  unsigned char iv_str[128];
481  unsigned char add_str[128];
482  unsigned char tag_str[128];
483  unsigned char output[128];
484  gcm_context ctx;
485  unsigned int key_len;
486  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
487  int ret;
488 
489  memset(key_str, 0x00, 128);
490  memset(src_str, 0x00, 128);
491  memset(dst_str, 0x00, 257);
492  memset(iv_str, 0x00, 128);
493  memset(add_str, 0x00, 128);
494  memset(tag_str, 0x00, 128);
495  memset(output, 0x00, 128);
496 
497  key_len = unhexify( key_str, "b02392fd7f228888c281e59d1eaa15fb" );
498  pt_len = unhexify( src_str, "" );
499  iv_len = unhexify( iv_str, "2726344ba8912c737e195424e1e6679e" );
500  add_len = unhexify( add_str, "" );
501  unhexify( tag_str, "a10b601ca8053536a2af2cc255d2b6" );
502 
503  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
504  if( 0 == 0 )
505  {
506  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
507 
508  if( strcmp( "FAIL", "" ) == 0 )
509  {
510  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
511  }
512  else
513  {
514  hexify( dst_str, output, pt_len );
515 
516  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
517  }
518  }
519  }
520  FCT_TEST_END();
521 
522 
523  FCT_TEST_BGN(gcm_nist_validation_aes_12812800112_0)
524  {
525  unsigned char key_str[128];
526  unsigned char src_str[128];
527  unsigned char dst_str[257];
528  unsigned char iv_str[128];
529  unsigned char add_str[128];
530  unsigned char tag_str[128];
531  unsigned char output[128];
532  gcm_context ctx;
533  unsigned int key_len;
534  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
535  int ret;
536 
537  memset(key_str, 0x00, 128);
538  memset(src_str, 0x00, 128);
539  memset(dst_str, 0x00, 257);
540  memset(iv_str, 0x00, 128);
541  memset(add_str, 0x00, 128);
542  memset(tag_str, 0x00, 128);
543  memset(output, 0x00, 128);
544 
545  key_len = unhexify( key_str, "21895cbafc16b7b8bf5867e88e0853d4" );
546  pt_len = unhexify( src_str, "" );
547  iv_len = unhexify( iv_str, "f987ce1005d9bbd31d2452fb80957753" );
548  add_len = unhexify( add_str, "" );
549  unhexify( tag_str, "952a7e265830d58a6778d68b9450" );
550 
551  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
552  if( 0 == 0 )
553  {
554  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
555 
556  if( strcmp( "FAIL", "" ) == 0 )
557  {
558  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
559  }
560  else
561  {
562  hexify( dst_str, output, pt_len );
563 
564  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
565  }
566  }
567  }
568  FCT_TEST_END();
569 
570 
571  FCT_TEST_BGN(gcm_nist_validation_aes_12812800112_1)
572  {
573  unsigned char key_str[128];
574  unsigned char src_str[128];
575  unsigned char dst_str[257];
576  unsigned char iv_str[128];
577  unsigned char add_str[128];
578  unsigned char tag_str[128];
579  unsigned char output[128];
580  gcm_context ctx;
581  unsigned int key_len;
582  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
583  int ret;
584 
585  memset(key_str, 0x00, 128);
586  memset(src_str, 0x00, 128);
587  memset(dst_str, 0x00, 257);
588  memset(iv_str, 0x00, 128);
589  memset(add_str, 0x00, 128);
590  memset(tag_str, 0x00, 128);
591  memset(output, 0x00, 128);
592 
593  key_len = unhexify( key_str, "9bb9742bf47f68caf64963d7c10a97b0" );
594  pt_len = unhexify( src_str, "" );
595  iv_len = unhexify( iv_str, "34a85669de64e1cd44731905fddbcbc5" );
596  add_len = unhexify( add_str, "" );
597  unhexify( tag_str, "e9b6be928aa77b2de28b480ae74c" );
598 
599  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
600  if( 0 == 0 )
601  {
602  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
603 
604  if( strcmp( "FAIL", "" ) == 0 )
605  {
606  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
607  }
608  else
609  {
610  hexify( dst_str, output, pt_len );
611 
612  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
613  }
614  }
615  }
616  FCT_TEST_END();
617 
618 
619  FCT_TEST_BGN(gcm_nist_validation_aes_12812800112_2)
620  {
621  unsigned char key_str[128];
622  unsigned char src_str[128];
623  unsigned char dst_str[257];
624  unsigned char iv_str[128];
625  unsigned char add_str[128];
626  unsigned char tag_str[128];
627  unsigned char output[128];
628  gcm_context ctx;
629  unsigned int key_len;
630  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
631  int ret;
632 
633  memset(key_str, 0x00, 128);
634  memset(src_str, 0x00, 128);
635  memset(dst_str, 0x00, 257);
636  memset(iv_str, 0x00, 128);
637  memset(add_str, 0x00, 128);
638  memset(tag_str, 0x00, 128);
639  memset(output, 0x00, 128);
640 
641  key_len = unhexify( key_str, "4e9708e4b37e2e1b5feaf4f5ab54e2a6" );
642  pt_len = unhexify( src_str, "" );
643  iv_len = unhexify( iv_str, "1c53a9fdd23919b036d99560619a9939" );
644  add_len = unhexify( add_str, "" );
645  unhexify( tag_str, "6611b50d6fbca83047f9f5fe1768" );
646 
647  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
648  if( 0 == 0 )
649  {
650  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
651 
652  if( strcmp( "FAIL", "" ) == 0 )
653  {
654  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
655  }
656  else
657  {
658  hexify( dst_str, output, pt_len );
659 
660  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
661  }
662  }
663  }
664  FCT_TEST_END();
665 
666 
667  FCT_TEST_BGN(gcm_nist_validation_aes_12812800104_0)
668  {
669  unsigned char key_str[128];
670  unsigned char src_str[128];
671  unsigned char dst_str[257];
672  unsigned char iv_str[128];
673  unsigned char add_str[128];
674  unsigned char tag_str[128];
675  unsigned char output[128];
676  gcm_context ctx;
677  unsigned int key_len;
678  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
679  int ret;
680 
681  memset(key_str, 0x00, 128);
682  memset(src_str, 0x00, 128);
683  memset(dst_str, 0x00, 257);
684  memset(iv_str, 0x00, 128);
685  memset(add_str, 0x00, 128);
686  memset(tag_str, 0x00, 128);
687  memset(output, 0x00, 128);
688 
689  key_len = unhexify( key_str, "82fede79db25f00be96eb050a22cea87" );
690  pt_len = unhexify( src_str, "" );
691  iv_len = unhexify( iv_str, "e9c50b517ab26c89b83c1f0cac50162c" );
692  add_len = unhexify( add_str, "" );
693  unhexify( tag_str, "d0c0ce9db60b77b0e31d05e048" );
694 
695  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
696  if( 0 == 0 )
697  {
698  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
699 
700  if( strcmp( "FAIL", "" ) == 0 )
701  {
702  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
703  }
704  else
705  {
706  hexify( dst_str, output, pt_len );
707 
708  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
709  }
710  }
711  }
712  FCT_TEST_END();
713 
714 
715  FCT_TEST_BGN(gcm_nist_validation_aes_12812800104_1)
716  {
717  unsigned char key_str[128];
718  unsigned char src_str[128];
719  unsigned char dst_str[257];
720  unsigned char iv_str[128];
721  unsigned char add_str[128];
722  unsigned char tag_str[128];
723  unsigned char output[128];
724  gcm_context ctx;
725  unsigned int key_len;
726  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
727  int ret;
728 
729  memset(key_str, 0x00, 128);
730  memset(src_str, 0x00, 128);
731  memset(dst_str, 0x00, 257);
732  memset(iv_str, 0x00, 128);
733  memset(add_str, 0x00, 128);
734  memset(tag_str, 0x00, 128);
735  memset(output, 0x00, 128);
736 
737  key_len = unhexify( key_str, "1d98566fca5201abb12914311a8bd532" );
738  pt_len = unhexify( src_str, "" );
739  iv_len = unhexify( iv_str, "590aef4b46a9023405d075edab7e6849" );
740  add_len = unhexify( add_str, "" );
741  unhexify( tag_str, "a1cfd1a27b341f49eda2ca8305" );
742 
743  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
744  if( 0 == 0 )
745  {
746  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
747 
748  if( strcmp( "FAIL", "FAIL" ) == 0 )
749  {
750  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
751  }
752  else
753  {
754  hexify( dst_str, output, pt_len );
755 
756  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
757  }
758  }
759  }
760  FCT_TEST_END();
761 
762 
763  FCT_TEST_BGN(gcm_nist_validation_aes_12812800104_2)
764  {
765  unsigned char key_str[128];
766  unsigned char src_str[128];
767  unsigned char dst_str[257];
768  unsigned char iv_str[128];
769  unsigned char add_str[128];
770  unsigned char tag_str[128];
771  unsigned char output[128];
772  gcm_context ctx;
773  unsigned int key_len;
774  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
775  int ret;
776 
777  memset(key_str, 0x00, 128);
778  memset(src_str, 0x00, 128);
779  memset(dst_str, 0x00, 257);
780  memset(iv_str, 0x00, 128);
781  memset(add_str, 0x00, 128);
782  memset(tag_str, 0x00, 128);
783  memset(output, 0x00, 128);
784 
785  key_len = unhexify( key_str, "3038771820c2e1319f02a74b8a7a0c08" );
786  pt_len = unhexify( src_str, "" );
787  iv_len = unhexify( iv_str, "e556d9f07fb69d7e9a644261c80fac92" );
788  add_len = unhexify( add_str, "" );
789  unhexify( tag_str, "4d2f005d662b6a8787f231c5e1" );
790 
791  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
792  if( 0 == 0 )
793  {
794  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
795 
796  if( strcmp( "FAIL", "FAIL" ) == 0 )
797  {
798  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
799  }
800  else
801  {
802  hexify( dst_str, output, pt_len );
803 
804  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
805  }
806  }
807  }
808  FCT_TEST_END();
809 
810 
811  FCT_TEST_BGN(gcm_nist_validation_aes_1281280096_0)
812  {
813  unsigned char key_str[128];
814  unsigned char src_str[128];
815  unsigned char dst_str[257];
816  unsigned char iv_str[128];
817  unsigned char add_str[128];
818  unsigned char tag_str[128];
819  unsigned char output[128];
820  gcm_context ctx;
821  unsigned int key_len;
822  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
823  int ret;
824 
825  memset(key_str, 0x00, 128);
826  memset(src_str, 0x00, 128);
827  memset(dst_str, 0x00, 257);
828  memset(iv_str, 0x00, 128);
829  memset(add_str, 0x00, 128);
830  memset(tag_str, 0x00, 128);
831  memset(output, 0x00, 128);
832 
833  key_len = unhexify( key_str, "0fb7eef50de598d7d8b508d019a30d5a" );
834  pt_len = unhexify( src_str, "" );
835  iv_len = unhexify( iv_str, "a2a2617040116c2c7e4236d2d8278213" );
836  add_len = unhexify( add_str, "" );
837  unhexify( tag_str, "68413c58df7bb5f067197ca0" );
838 
839  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
840  if( 0 == 0 )
841  {
842  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
843 
844  if( strcmp( "FAIL", "FAIL" ) == 0 )
845  {
846  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
847  }
848  else
849  {
850  hexify( dst_str, output, pt_len );
851 
852  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
853  }
854  }
855  }
856  FCT_TEST_END();
857 
858 
859  FCT_TEST_BGN(gcm_nist_validation_aes_1281280096_1)
860  {
861  unsigned char key_str[128];
862  unsigned char src_str[128];
863  unsigned char dst_str[257];
864  unsigned char iv_str[128];
865  unsigned char add_str[128];
866  unsigned char tag_str[128];
867  unsigned char output[128];
868  gcm_context ctx;
869  unsigned int key_len;
870  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
871  int ret;
872 
873  memset(key_str, 0x00, 128);
874  memset(src_str, 0x00, 128);
875  memset(dst_str, 0x00, 257);
876  memset(iv_str, 0x00, 128);
877  memset(add_str, 0x00, 128);
878  memset(tag_str, 0x00, 128);
879  memset(output, 0x00, 128);
880 
881  key_len = unhexify( key_str, "8cc58b609204215c8ab4908286e56e5c" );
882  pt_len = unhexify( src_str, "" );
883  iv_len = unhexify( iv_str, "fb83ea637279332677b5f68081173e99" );
884  add_len = unhexify( add_str, "" );
885  unhexify( tag_str, "a2a9160d82739a55d8cd419f" );
886 
887  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
888  if( 0 == 0 )
889  {
890  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
891 
892  if( strcmp( "FAIL", "FAIL" ) == 0 )
893  {
894  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
895  }
896  else
897  {
898  hexify( dst_str, output, pt_len );
899 
900  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
901  }
902  }
903  }
904  FCT_TEST_END();
905 
906 
907  FCT_TEST_BGN(gcm_nist_validation_aes_1281280096_2)
908  {
909  unsigned char key_str[128];
910  unsigned char src_str[128];
911  unsigned char dst_str[257];
912  unsigned char iv_str[128];
913  unsigned char add_str[128];
914  unsigned char tag_str[128];
915  unsigned char output[128];
916  gcm_context ctx;
917  unsigned int key_len;
918  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
919  int ret;
920 
921  memset(key_str, 0x00, 128);
922  memset(src_str, 0x00, 128);
923  memset(dst_str, 0x00, 257);
924  memset(iv_str, 0x00, 128);
925  memset(add_str, 0x00, 128);
926  memset(tag_str, 0x00, 128);
927  memset(output, 0x00, 128);
928 
929  key_len = unhexify( key_str, "81a5fd184742a478432963f6477e8f92" );
930  pt_len = unhexify( src_str, "" );
931  iv_len = unhexify( iv_str, "da297cbb53b11d7c379e0566299b4d5a" );
932  add_len = unhexify( add_str, "" );
933  unhexify( tag_str, "200bee49466fdda2f21f0062" );
934 
935  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
936  if( 0 == 0 )
937  {
938  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
939 
940  if( strcmp( "FAIL", "FAIL" ) == 0 )
941  {
942  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
943  }
944  else
945  {
946  hexify( dst_str, output, pt_len );
947 
948  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
949  }
950  }
951  }
952  FCT_TEST_END();
953 
954 
955  FCT_TEST_BGN(gcm_nist_validation_aes_1281280064_0)
956  {
957  unsigned char key_str[128];
958  unsigned char src_str[128];
959  unsigned char dst_str[257];
960  unsigned char iv_str[128];
961  unsigned char add_str[128];
962  unsigned char tag_str[128];
963  unsigned char output[128];
964  gcm_context ctx;
965  unsigned int key_len;
966  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
967  int ret;
968 
969  memset(key_str, 0x00, 128);
970  memset(src_str, 0x00, 128);
971  memset(dst_str, 0x00, 257);
972  memset(iv_str, 0x00, 128);
973  memset(add_str, 0x00, 128);
974  memset(tag_str, 0x00, 128);
975  memset(output, 0x00, 128);
976 
977  key_len = unhexify( key_str, "f604ac66d626959e595cbb7b4128e096" );
978  pt_len = unhexify( src_str, "" );
979  iv_len = unhexify( iv_str, "269d2a49d533c6bb38008711f38e0b39" );
980  add_len = unhexify( add_str, "" );
981  unhexify( tag_str, "468200fa4683e8be" );
982 
983  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
984  if( 0 == 0 )
985  {
986  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
987 
988  if( strcmp( "FAIL", "FAIL" ) == 0 )
989  {
990  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
991  }
992  else
993  {
994  hexify( dst_str, output, pt_len );
995 
996  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
997  }
998  }
999  }
1000  FCT_TEST_END();
1001 
1002 
1003  FCT_TEST_BGN(gcm_nist_validation_aes_1281280064_1)
1004  {
1005  unsigned char key_str[128];
1006  unsigned char src_str[128];
1007  unsigned char dst_str[257];
1008  unsigned char iv_str[128];
1009  unsigned char add_str[128];
1010  unsigned char tag_str[128];
1011  unsigned char output[128];
1012  gcm_context ctx;
1013  unsigned int key_len;
1014  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
1015  int ret;
1016 
1017  memset(key_str, 0x00, 128);
1018  memset(src_str, 0x00, 128);
1019  memset(dst_str, 0x00, 257);
1020  memset(iv_str, 0x00, 128);
1021  memset(add_str, 0x00, 128);
1022  memset(tag_str, 0x00, 128);
1023  memset(output, 0x00, 128);
1024 
1025  key_len = unhexify( key_str, "2e308ba7903e925f768c1d00ff3eb623" );
1026  pt_len = unhexify( src_str, "" );
1027  iv_len = unhexify( iv_str, "335acd2aa48a47a37cfe21e491f1b141" );
1028  add_len = unhexify( add_str, "" );
1029  unhexify( tag_str, "4872bfd5e2ff55f6" );
1030 
1031  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1032  if( 0 == 0 )
1033  {
1034  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1035 
1036  if( strcmp( "FAIL", "" ) == 0 )
1037  {
1038  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1039  }
1040  else
1041  {
1042  hexify( dst_str, output, pt_len );
1043 
1044  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1045  }
1046  }
1047  }
1048  FCT_TEST_END();
1049 
1050 
1051  FCT_TEST_BGN(gcm_nist_validation_aes_1281280064_2)
1052  {
1053  unsigned char key_str[128];
1054  unsigned char src_str[128];
1055  unsigned char dst_str[257];
1056  unsigned char iv_str[128];
1057  unsigned char add_str[128];
1058  unsigned char tag_str[128];
1059  unsigned char output[128];
1060  gcm_context ctx;
1061  unsigned int key_len;
1062  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
1063  int ret;
1064 
1065  memset(key_str, 0x00, 128);
1066  memset(src_str, 0x00, 128);
1067  memset(dst_str, 0x00, 257);
1068  memset(iv_str, 0x00, 128);
1069  memset(add_str, 0x00, 128);
1070  memset(tag_str, 0x00, 128);
1071  memset(output, 0x00, 128);
1072 
1073  key_len = unhexify( key_str, "1304e2a5a3520454a5109df61a67da7a" );
1074  pt_len = unhexify( src_str, "" );
1075  iv_len = unhexify( iv_str, "dbe8b452acf4fa1444c3668e9ee72d26" );
1076  add_len = unhexify( add_str, "" );
1077  unhexify( tag_str, "83a0d3440200ca95" );
1078 
1079  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1080  if( 0 == 0 )
1081  {
1082  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1083 
1084  if( strcmp( "FAIL", "FAIL" ) == 0 )
1085  {
1086  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1087  }
1088  else
1089  {
1090  hexify( dst_str, output, pt_len );
1091 
1092  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1093  }
1094  }
1095  }
1096  FCT_TEST_END();
1097 
1098 
1099  FCT_TEST_BGN(gcm_nist_validation_aes_1281280032_0)
1100  {
1101  unsigned char key_str[128];
1102  unsigned char src_str[128];
1103  unsigned char dst_str[257];
1104  unsigned char iv_str[128];
1105  unsigned char add_str[128];
1106  unsigned char tag_str[128];
1107  unsigned char output[128];
1108  gcm_context ctx;
1109  unsigned int key_len;
1110  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
1111  int ret;
1112 
1113  memset(key_str, 0x00, 128);
1114  memset(src_str, 0x00, 128);
1115  memset(dst_str, 0x00, 257);
1116  memset(iv_str, 0x00, 128);
1117  memset(add_str, 0x00, 128);
1118  memset(tag_str, 0x00, 128);
1119  memset(output, 0x00, 128);
1120 
1121  key_len = unhexify( key_str, "ecf1ec2c9a8f2e9cc799f9b9fddb3232" );
1122  pt_len = unhexify( src_str, "" );
1123  iv_len = unhexify( iv_str, "ddf0b695aef5df2b594fcaae72b7e41c" );
1124  add_len = unhexify( add_str, "" );
1125  unhexify( tag_str, "2819aedf" );
1126 
1127  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1128  if( 0 == 0 )
1129  {
1130  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1131 
1132  if( strcmp( "FAIL", "" ) == 0 )
1133  {
1134  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1135  }
1136  else
1137  {
1138  hexify( dst_str, output, pt_len );
1139 
1140  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1141  }
1142  }
1143  }
1144  FCT_TEST_END();
1145 
1146 
1147  FCT_TEST_BGN(gcm_nist_validation_aes_1281280032_1)
1148  {
1149  unsigned char key_str[128];
1150  unsigned char src_str[128];
1151  unsigned char dst_str[257];
1152  unsigned char iv_str[128];
1153  unsigned char add_str[128];
1154  unsigned char tag_str[128];
1155  unsigned char output[128];
1156  gcm_context ctx;
1157  unsigned int key_len;
1158  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
1159  int ret;
1160 
1161  memset(key_str, 0x00, 128);
1162  memset(src_str, 0x00, 128);
1163  memset(dst_str, 0x00, 257);
1164  memset(iv_str, 0x00, 128);
1165  memset(add_str, 0x00, 128);
1166  memset(tag_str, 0x00, 128);
1167  memset(output, 0x00, 128);
1168 
1169  key_len = unhexify( key_str, "9ab5c8ca905b5fe50461f4a68941144b" );
1170  pt_len = unhexify( src_str, "" );
1171  iv_len = unhexify( iv_str, "96dd3927a96e16123f2e9d6b367d303f" );
1172  add_len = unhexify( add_str, "" );
1173  unhexify( tag_str, "6e0c53ef" );
1174 
1175  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1176  if( 0 == 0 )
1177  {
1178  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1179 
1180  if( strcmp( "FAIL", "" ) == 0 )
1181  {
1182  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1183  }
1184  else
1185  {
1186  hexify( dst_str, output, pt_len );
1187 
1188  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1189  }
1190  }
1191  }
1192  FCT_TEST_END();
1193 
1194 
1195  FCT_TEST_BGN(gcm_nist_validation_aes_1281280032_2)
1196  {
1197  unsigned char key_str[128];
1198  unsigned char src_str[128];
1199  unsigned char dst_str[257];
1200  unsigned char iv_str[128];
1201  unsigned char add_str[128];
1202  unsigned char tag_str[128];
1203  unsigned char output[128];
1204  gcm_context ctx;
1205  unsigned int key_len;
1206  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
1207  int ret;
1208 
1209  memset(key_str, 0x00, 128);
1210  memset(src_str, 0x00, 128);
1211  memset(dst_str, 0x00, 257);
1212  memset(iv_str, 0x00, 128);
1213  memset(add_str, 0x00, 128);
1214  memset(tag_str, 0x00, 128);
1215  memset(output, 0x00, 128);
1216 
1217  key_len = unhexify( key_str, "b5fc7af605721a9cfe61c1ee6a4b3e22" );
1218  pt_len = unhexify( src_str, "" );
1219  iv_len = unhexify( iv_str, "6b757d4055823d1035d01077666037d6" );
1220  add_len = unhexify( add_str, "" );
1221  unhexify( tag_str, "e8c09ddd" );
1222 
1223  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1224  if( 0 == 0 )
1225  {
1226  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1227 
1228  if( strcmp( "FAIL", "FAIL" ) == 0 )
1229  {
1230  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1231  }
1232  else
1233  {
1234  hexify( dst_str, output, pt_len );
1235 
1236  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1237  }
1238  }
1239  }
1240  FCT_TEST_END();
1241 
1242 
1243  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024128_0)
1244  {
1245  unsigned char key_str[128];
1246  unsigned char src_str[128];
1247  unsigned char dst_str[257];
1248  unsigned char iv_str[128];
1249  unsigned char add_str[128];
1250  unsigned char tag_str[128];
1251  unsigned char output[128];
1252  gcm_context ctx;
1253  unsigned int key_len;
1254  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
1255  int ret;
1256 
1257  memset(key_str, 0x00, 128);
1258  memset(src_str, 0x00, 128);
1259  memset(dst_str, 0x00, 257);
1260  memset(iv_str, 0x00, 128);
1261  memset(add_str, 0x00, 128);
1262  memset(tag_str, 0x00, 128);
1263  memset(output, 0x00, 128);
1264 
1265  key_len = unhexify( key_str, "03c0b4a6e508a8490db0d086a82c9db7" );
1266  pt_len = unhexify( src_str, "" );
1267  iv_len = unhexify( iv_str, "ac52f6c1a05030321fa39f87e89fdb5e" );
1268  add_len = unhexify( add_str, "33316ca79d10a79f4fd038593e8eef09625089dc4e0ffe4bc1f2871554fa6666ab3e7fe7885edef694b410456f3ec0e513bb25f1b48d95e4820c5972c1aabb25c84c08566002dadc36df334c1ce86847964a122016d389ac873bca8c335a7a99bcef91e1b985ae5d488a2d7f78b4bf14e0c2dc715e814f4e24276057cf668172" );
1269  unhexify( tag_str, "756292d8b4653887edef51679b161812" );
1270 
1271  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1272  if( 0 == 0 )
1273  {
1274  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1275 
1276  if( strcmp( "FAIL", "FAIL" ) == 0 )
1277  {
1278  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1279  }
1280  else
1281  {
1282  hexify( dst_str, output, pt_len );
1283 
1284  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1285  }
1286  }
1287  }
1288  FCT_TEST_END();
1289 
1290 
1291  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024128_1)
1292  {
1293  unsigned char key_str[128];
1294  unsigned char src_str[128];
1295  unsigned char dst_str[257];
1296  unsigned char iv_str[128];
1297  unsigned char add_str[128];
1298  unsigned char tag_str[128];
1299  unsigned char output[128];
1300  gcm_context ctx;
1301  unsigned int key_len;
1302  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
1303  int ret;
1304 
1305  memset(key_str, 0x00, 128);
1306  memset(src_str, 0x00, 128);
1307  memset(dst_str, 0x00, 257);
1308  memset(iv_str, 0x00, 128);
1309  memset(add_str, 0x00, 128);
1310  memset(tag_str, 0x00, 128);
1311  memset(output, 0x00, 128);
1312 
1313  key_len = unhexify( key_str, "b228d3d15219ea9ad5651fce02c8374d" );
1314  pt_len = unhexify( src_str, "" );
1315  iv_len = unhexify( iv_str, "5c7eafaead029c3fe3cf3835fe758d0e" );
1316  add_len = unhexify( add_str, "8c35dd805c08686b9b4d460f81b4dcb8c46c6d57842dc3e72ba90952e2bebf17fe7184445b02f801800a944486d662a127d01d3b7f42679052cdc73ce533129af8d13957415c5495142157d6ce8a68aa977e56f562fed98e468e42522767656ce50369471060381bb752dd5e77c79677a4cadffa39e518e30a789e793b07ea21" );
1317  unhexify( tag_str, "a4dde1ab93c84937c3bbc3ad5237818d" );
1318 
1319  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1320  if( 0 == 0 )
1321  {
1322  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1323 
1324  if( strcmp( "FAIL", "FAIL" ) == 0 )
1325  {
1326  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1327  }
1328  else
1329  {
1330  hexify( dst_str, output, pt_len );
1331 
1332  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1333  }
1334  }
1335  }
1336  FCT_TEST_END();
1337 
1338 
1339  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024128_2)
1340  {
1341  unsigned char key_str[128];
1342  unsigned char src_str[128];
1343  unsigned char dst_str[257];
1344  unsigned char iv_str[128];
1345  unsigned char add_str[128];
1346  unsigned char tag_str[128];
1347  unsigned char output[128];
1348  gcm_context ctx;
1349  unsigned int key_len;
1350  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
1351  int ret;
1352 
1353  memset(key_str, 0x00, 128);
1354  memset(src_str, 0x00, 128);
1355  memset(dst_str, 0x00, 257);
1356  memset(iv_str, 0x00, 128);
1357  memset(add_str, 0x00, 128);
1358  memset(tag_str, 0x00, 128);
1359  memset(output, 0x00, 128);
1360 
1361  key_len = unhexify( key_str, "776afcbabedd5577fe660a60f920b536" );
1362  pt_len = unhexify( src_str, "" );
1363  iv_len = unhexify( iv_str, "5bbb7f1b14084e520408dd87b97705e9" );
1364  add_len = unhexify( add_str, "44631fc9d4a07416b0dfb4e2b42071e3e2be45502c9ddf72b3e61810eeda31a7d685ebb2ee43a2c06af374569f439ee1668c550067de2dece9ec46ee72b260858d6033f814e85275c5ae669b60803a8c516de32804fa34d3a213ccfaf6689046e25eeb30b9e1608e689f4d31cc664b83a468a51165f5625f12f098a6bf7ddab2" );
1365  unhexify( tag_str, "a5347d41d93b587240651bcd5230264f" );
1366 
1367  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1368  if( 0 == 0 )
1369  {
1370  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1371 
1372  if( strcmp( "FAIL", "FAIL" ) == 0 )
1373  {
1374  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1375  }
1376  else
1377  {
1378  hexify( dst_str, output, pt_len );
1379 
1380  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1381  }
1382  }
1383  }
1384  FCT_TEST_END();
1385 
1386 
1387  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024120_0)
1388  {
1389  unsigned char key_str[128];
1390  unsigned char src_str[128];
1391  unsigned char dst_str[257];
1392  unsigned char iv_str[128];
1393  unsigned char add_str[128];
1394  unsigned char tag_str[128];
1395  unsigned char output[128];
1396  gcm_context ctx;
1397  unsigned int key_len;
1398  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
1399  int ret;
1400 
1401  memset(key_str, 0x00, 128);
1402  memset(src_str, 0x00, 128);
1403  memset(dst_str, 0x00, 257);
1404  memset(iv_str, 0x00, 128);
1405  memset(add_str, 0x00, 128);
1406  memset(tag_str, 0x00, 128);
1407  memset(output, 0x00, 128);
1408 
1409  key_len = unhexify( key_str, "20abeafa25fc4ea7d0592cb3e9b4d5fe" );
1410  pt_len = unhexify( src_str, "" );
1411  iv_len = unhexify( iv_str, "3aba79a58c5aa664856b41d552c7a8d3" );
1412  add_len = unhexify( add_str, "98cfecaae9eb9a7c3b17e6bc5f80d8a4bf7a9f4fa5e01b74cae15ee6af14633205aafe3b28fb7b7918e12322ea27352056a603746d728a61361134a561619400ff2bf679045bac2e0fbc2c1d41f8faba4b27c7827bceda4e9bf505df4185515dd3a5e26f7639c8ad5a38bc5906a44be062f02cc53862678ae36fa3de3c02c982" );
1413  unhexify( tag_str, "2a67ad1471a520fe09a304f0975f31" );
1414 
1415  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1416  if( 0 == 0 )
1417  {
1418  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1419 
1420  if( strcmp( "FAIL", "FAIL" ) == 0 )
1421  {
1422  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1423  }
1424  else
1425  {
1426  hexify( dst_str, output, pt_len );
1427 
1428  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1429  }
1430  }
1431  }
1432  FCT_TEST_END();
1433 
1434 
1435  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024120_1)
1436  {
1437  unsigned char key_str[128];
1438  unsigned char src_str[128];
1439  unsigned char dst_str[257];
1440  unsigned char iv_str[128];
1441  unsigned char add_str[128];
1442  unsigned char tag_str[128];
1443  unsigned char output[128];
1444  gcm_context ctx;
1445  unsigned int key_len;
1446  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
1447  int ret;
1448 
1449  memset(key_str, 0x00, 128);
1450  memset(src_str, 0x00, 128);
1451  memset(dst_str, 0x00, 257);
1452  memset(iv_str, 0x00, 128);
1453  memset(add_str, 0x00, 128);
1454  memset(tag_str, 0x00, 128);
1455  memset(output, 0x00, 128);
1456 
1457  key_len = unhexify( key_str, "2bc73fba942ff105823b5dccf6befb1c" );
1458  pt_len = unhexify( src_str, "" );
1459  iv_len = unhexify( iv_str, "902c3e3b69b1ef8395d7281ff74cce38" );
1460  add_len = unhexify( add_str, "4adec0b4ac00325a860044d9f9519daa4f7c163229a75819b0fd7d8e23319f030e61dfa8eadabff42ea27bc36bdb6cad249e801ca631b656836448b7172c11126bad2781e6a1aa4f62c4eda53409408b008c057e0b81215cc13ddabbb8f1915f4bbab854f8b00763a530ad5055d265778cd3080d0bd35b76a329bdd5b5a2d268" );
1461  unhexify( tag_str, "ebdd7c8e87fe733138a433543542d1" );
1462 
1463  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1464  if( 0 == 0 )
1465  {
1466  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1467 
1468  if( strcmp( "FAIL", "" ) == 0 )
1469  {
1470  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1471  }
1472  else
1473  {
1474  hexify( dst_str, output, pt_len );
1475 
1476  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1477  }
1478  }
1479  }
1480  FCT_TEST_END();
1481 
1482 
1483  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024120_2)
1484  {
1485  unsigned char key_str[128];
1486  unsigned char src_str[128];
1487  unsigned char dst_str[257];
1488  unsigned char iv_str[128];
1489  unsigned char add_str[128];
1490  unsigned char tag_str[128];
1491  unsigned char output[128];
1492  gcm_context ctx;
1493  unsigned int key_len;
1494  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
1495  int ret;
1496 
1497  memset(key_str, 0x00, 128);
1498  memset(src_str, 0x00, 128);
1499  memset(dst_str, 0x00, 257);
1500  memset(iv_str, 0x00, 128);
1501  memset(add_str, 0x00, 128);
1502  memset(tag_str, 0x00, 128);
1503  memset(output, 0x00, 128);
1504 
1505  key_len = unhexify( key_str, "356a4c245868243d61756cabe86da887" );
1506  pt_len = unhexify( src_str, "" );
1507  iv_len = unhexify( iv_str, "b442f2ec6d45a17144c258fd59fe5b3b" );
1508  add_len = unhexify( add_str, "12cccc3c60474b0a1579c5006c2134850724fa6c9da3a7022d4f65fd238b052bdf34ea34aa7dbadad64996065acee588ab6bd29726d07ed24ffae2d33aadf3e66ebb87f57e689fd85128be1c9e3d8362fad1f8096ee391f75b576fb213d394cef6f091fc5488d9aa152be69475b9167abd6dd4fd93bbbc7b8ca316c952eb19c6" );
1509  unhexify( tag_str, "ed26080dcb670590613d97d7c47cf4" );
1510 
1511  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1512  if( 0 == 0 )
1513  {
1514  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1515 
1516  if( strcmp( "FAIL", "FAIL" ) == 0 )
1517  {
1518  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1519  }
1520  else
1521  {
1522  hexify( dst_str, output, pt_len );
1523 
1524  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1525  }
1526  }
1527  }
1528  FCT_TEST_END();
1529 
1530 
1531  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024112_0)
1532  {
1533  unsigned char key_str[128];
1534  unsigned char src_str[128];
1535  unsigned char dst_str[257];
1536  unsigned char iv_str[128];
1537  unsigned char add_str[128];
1538  unsigned char tag_str[128];
1539  unsigned char output[128];
1540  gcm_context ctx;
1541  unsigned int key_len;
1542  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
1543  int ret;
1544 
1545  memset(key_str, 0x00, 128);
1546  memset(src_str, 0x00, 128);
1547  memset(dst_str, 0x00, 257);
1548  memset(iv_str, 0x00, 128);
1549  memset(add_str, 0x00, 128);
1550  memset(tag_str, 0x00, 128);
1551  memset(output, 0x00, 128);
1552 
1553  key_len = unhexify( key_str, "dfa7e93aff73600fc552324253066e2c" );
1554  pt_len = unhexify( src_str, "" );
1555  iv_len = unhexify( iv_str, "c20001e93f1cd05253c277a9445d61e4" );
1556  add_len = unhexify( add_str, "a64d1e20058a1f7e698622a02f7ff8dc11886717ede17bbdc3c4645a66a71d8b04346fb389a251ffb0a7f445a25faf642bb7e4697d2cacf925e78c4be98457996afb25b0516b50f179441d1923312364947f8f1e0f5715b43bd537727bf943d7b4679b0b0b28b94e56e7bbf554d9cf79fcee4387f32bb6f91efdd23620035be6" );
1557  unhexify( tag_str, "6ba5e4dace9a54b50b901d9b73ad" );
1558 
1559  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1560  if( 0 == 0 )
1561  {
1562  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1563 
1564  if( strcmp( "FAIL", "" ) == 0 )
1565  {
1566  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1567  }
1568  else
1569  {
1570  hexify( dst_str, output, pt_len );
1571 
1572  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1573  }
1574  }
1575  }
1576  FCT_TEST_END();
1577 
1578 
1579  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024112_1)
1580  {
1581  unsigned char key_str[128];
1582  unsigned char src_str[128];
1583  unsigned char dst_str[257];
1584  unsigned char iv_str[128];
1585  unsigned char add_str[128];
1586  unsigned char tag_str[128];
1587  unsigned char output[128];
1588  gcm_context ctx;
1589  unsigned int key_len;
1590  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
1591  int ret;
1592 
1593  memset(key_str, 0x00, 128);
1594  memset(src_str, 0x00, 128);
1595  memset(dst_str, 0x00, 257);
1596  memset(iv_str, 0x00, 128);
1597  memset(add_str, 0x00, 128);
1598  memset(tag_str, 0x00, 128);
1599  memset(output, 0x00, 128);
1600 
1601  key_len = unhexify( key_str, "2ecea80b48d2ecd194a7699aa7d8ccfc" );
1602  pt_len = unhexify( src_str, "" );
1603  iv_len = unhexify( iv_str, "8b4db08bafc23b65ae50a2d20661d270" );
1604  add_len = unhexify( add_str, "efc2ca1a3b41b90f8ddf74291d68f072a6e025d0c91c3ce2b133525943c73ebadc71f150be20afeb097442fa51be31a641df65d90ebd81dcbaf32711ed31f5e0271421377ffe14ddafea3ca60a600588d484856a98de73f56a766ae60bae384a4ae01a1a06821cf0c7a6b4ee4c8f413748457b3777283d3310218fb55c107293" );
1605  unhexify( tag_str, "246a9d37553088b6411ebb62aa16" );
1606 
1607  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1608  if( 0 == 0 )
1609  {
1610  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1611 
1612  if( strcmp( "FAIL", "" ) == 0 )
1613  {
1614  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1615  }
1616  else
1617  {
1618  hexify( dst_str, output, pt_len );
1619 
1620  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1621  }
1622  }
1623  }
1624  FCT_TEST_END();
1625 
1626 
1627  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024112_2)
1628  {
1629  unsigned char key_str[128];
1630  unsigned char src_str[128];
1631  unsigned char dst_str[257];
1632  unsigned char iv_str[128];
1633  unsigned char add_str[128];
1634  unsigned char tag_str[128];
1635  unsigned char output[128];
1636  gcm_context ctx;
1637  unsigned int key_len;
1638  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
1639  int ret;
1640 
1641  memset(key_str, 0x00, 128);
1642  memset(src_str, 0x00, 128);
1643  memset(dst_str, 0x00, 257);
1644  memset(iv_str, 0x00, 128);
1645  memset(add_str, 0x00, 128);
1646  memset(tag_str, 0x00, 128);
1647  memset(output, 0x00, 128);
1648 
1649  key_len = unhexify( key_str, "d38fee3fd3d6d08224c3c83529a25d08" );
1650  pt_len = unhexify( src_str, "" );
1651  iv_len = unhexify( iv_str, "a942ccb11cf9468186fabfc18c899801" );
1652  add_len = unhexify( add_str, "1c92a4ce0a1dae27e720d6f9b1e460276538de437f3812ab1177cf0273b05908f296f33ba0f4c790abe2ce958b1d92b930a0d81243e6ad09ef86ee8e3270243095096537cb1054fcfcf537d828b65af9b6cf7c50f5b8470f7908f314d0859107eed772ee1732c78e8a2e35b2493f3e8c1e601b08aeab8d9729e0294dca168c62" );
1653  unhexify( tag_str, "803a08700ec86fdeb88f7a388921" );
1654 
1655  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1656  if( 0 == 0 )
1657  {
1658  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1659 
1660  if( strcmp( "FAIL", "FAIL" ) == 0 )
1661  {
1662  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1663  }
1664  else
1665  {
1666  hexify( dst_str, output, pt_len );
1667 
1668  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1669  }
1670  }
1671  }
1672  FCT_TEST_END();
1673 
1674 
1675  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024104_0)
1676  {
1677  unsigned char key_str[128];
1678  unsigned char src_str[128];
1679  unsigned char dst_str[257];
1680  unsigned char iv_str[128];
1681  unsigned char add_str[128];
1682  unsigned char tag_str[128];
1683  unsigned char output[128];
1684  gcm_context ctx;
1685  unsigned int key_len;
1686  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
1687  int ret;
1688 
1689  memset(key_str, 0x00, 128);
1690  memset(src_str, 0x00, 128);
1691  memset(dst_str, 0x00, 257);
1692  memset(iv_str, 0x00, 128);
1693  memset(add_str, 0x00, 128);
1694  memset(tag_str, 0x00, 128);
1695  memset(output, 0x00, 128);
1696 
1697  key_len = unhexify( key_str, "1899b0cbae41d705c6eed3226afb5bc0" );
1698  pt_len = unhexify( src_str, "" );
1699  iv_len = unhexify( iv_str, "82d0910aa53e300a487d880d018d0dea" );
1700  add_len = unhexify( add_str, "6bf5583cc1007d74f3529db63b8d4e085400ccf3725eab8e19cb145f3910c61465a21486740a26f74691866a9f632af9fae81f5f0bffedf0c28a6ce0fd520bb4db04a3cd1a7d29d8801e05e4b9c9374fd89bcb539489c2f7f1f801c253a1cc737408669bcd133b62da357f7399a52179125aa59fae6707d340846886d730a835" );
1701  unhexify( tag_str, "c5d58870fee9ce157f5ec1fa8f" );
1702 
1703  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1704  if( 0 == 0 )
1705  {
1706  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1707 
1708  if( strcmp( "FAIL", "" ) == 0 )
1709  {
1710  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1711  }
1712  else
1713  {
1714  hexify( dst_str, output, pt_len );
1715 
1716  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1717  }
1718  }
1719  }
1720  FCT_TEST_END();
1721 
1722 
1723  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024104_1)
1724  {
1725  unsigned char key_str[128];
1726  unsigned char src_str[128];
1727  unsigned char dst_str[257];
1728  unsigned char iv_str[128];
1729  unsigned char add_str[128];
1730  unsigned char tag_str[128];
1731  unsigned char output[128];
1732  gcm_context ctx;
1733  unsigned int key_len;
1734  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
1735  int ret;
1736 
1737  memset(key_str, 0x00, 128);
1738  memset(src_str, 0x00, 128);
1739  memset(dst_str, 0x00, 257);
1740  memset(iv_str, 0x00, 128);
1741  memset(add_str, 0x00, 128);
1742  memset(tag_str, 0x00, 128);
1743  memset(output, 0x00, 128);
1744 
1745  key_len = unhexify( key_str, "8b95323d86d02754f4c2874b42ec6eb0" );
1746  pt_len = unhexify( src_str, "" );
1747  iv_len = unhexify( iv_str, "4f76084acbdef9999c71dcc794238d7c" );
1748  add_len = unhexify( add_str, "ebc75788377c0b264818a6f97c19cf92c29f1c7cdeb6b5f0a92d238fa4614bc35d0cfe4ec9d045cd628ff6262c460679ac15b0c6366d9289bbd217e5012279e0af0fb2cfcbdf51fe16935968cbb727f725fe5bcd4428905849746c8493600ce8b2cfc1b61b04c8b752b915fed611d6b54ef73ec4e3950d6db1807b1ce7ed1dcc" );
1749  unhexify( tag_str, "c4724ff1d2c57295eb733e9cad" );
1750 
1751  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1752  if( 0 == 0 )
1753  {
1754  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1755 
1756  if( strcmp( "FAIL", "FAIL" ) == 0 )
1757  {
1758  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1759  }
1760  else
1761  {
1762  hexify( dst_str, output, pt_len );
1763 
1764  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1765  }
1766  }
1767  }
1768  FCT_TEST_END();
1769 
1770 
1771  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024104_2)
1772  {
1773  unsigned char key_str[128];
1774  unsigned char src_str[128];
1775  unsigned char dst_str[257];
1776  unsigned char iv_str[128];
1777  unsigned char add_str[128];
1778  unsigned char tag_str[128];
1779  unsigned char output[128];
1780  gcm_context ctx;
1781  unsigned int key_len;
1782  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
1783  int ret;
1784 
1785  memset(key_str, 0x00, 128);
1786  memset(src_str, 0x00, 128);
1787  memset(dst_str, 0x00, 257);
1788  memset(iv_str, 0x00, 128);
1789  memset(add_str, 0x00, 128);
1790  memset(tag_str, 0x00, 128);
1791  memset(output, 0x00, 128);
1792 
1793  key_len = unhexify( key_str, "30da555559eb11cf7e0eff9d99e9607d" );
1794  pt_len = unhexify( src_str, "" );
1795  iv_len = unhexify( iv_str, "7799275bf12335f281ec94a870f90a0b" );
1796  add_len = unhexify( add_str, "e735d556e15aec78d9736016c8c99db753ed14d4e4adaaa1dd7eaad702ea5dc337433f8c2b45afdf2f385fdf6c55574425571e079ca759b6235f877ed11618ff212bafd865a22b80b76b3b5cf1acfd24d92fd41607bbb7382f26cd703757088d497b16b32de80e1256c734a9b83356b6fced207177de75458481eaef59a431d7" );
1797  unhexify( tag_str, "3c82272130e17c4a0a007a908e" );
1798 
1799  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1800  if( 0 == 0 )
1801  {
1802  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1803 
1804  if( strcmp( "FAIL", "" ) == 0 )
1805  {
1806  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1807  }
1808  else
1809  {
1810  hexify( dst_str, output, pt_len );
1811 
1812  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1813  }
1814  }
1815  }
1816  FCT_TEST_END();
1817 
1818 
1819  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102496_0)
1820  {
1821  unsigned char key_str[128];
1822  unsigned char src_str[128];
1823  unsigned char dst_str[257];
1824  unsigned char iv_str[128];
1825  unsigned char add_str[128];
1826  unsigned char tag_str[128];
1827  unsigned char output[128];
1828  gcm_context ctx;
1829  unsigned int key_len;
1830  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
1831  int ret;
1832 
1833  memset(key_str, 0x00, 128);
1834  memset(src_str, 0x00, 128);
1835  memset(dst_str, 0x00, 257);
1836  memset(iv_str, 0x00, 128);
1837  memset(add_str, 0x00, 128);
1838  memset(tag_str, 0x00, 128);
1839  memset(output, 0x00, 128);
1840 
1841  key_len = unhexify( key_str, "ed2ac74af896c5190c271cfa6af02fd2" );
1842  pt_len = unhexify( src_str, "" );
1843  iv_len = unhexify( iv_str, "e0226e2d8da47badad1fb78b9a797f27" );
1844  add_len = unhexify( add_str, "8f11353ae476ff923013e6e736ffc9d23101a1c471ccc07ad372a8430d6559c376075efce2e318cdf4c9443dbf132e7e6da5524045028c97e904633b44c4d189a4b64237ac7692dd03c0e751ce9f04d0fdbd8a96074cd7dfa2fd441a52328b4ac3974b4902db45663f7b6f24947dba618f8b9769e927faf84c9f49ad8239b9fb" );
1845  unhexify( tag_str, "db8af7a0d548fc54d9457c73" );
1846 
1847  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1848  if( 0 == 0 )
1849  {
1850  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1851 
1852  if( strcmp( "FAIL", "" ) == 0 )
1853  {
1854  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1855  }
1856  else
1857  {
1858  hexify( dst_str, output, pt_len );
1859 
1860  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1861  }
1862  }
1863  }
1864  FCT_TEST_END();
1865 
1866 
1867  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102496_1)
1868  {
1869  unsigned char key_str[128];
1870  unsigned char src_str[128];
1871  unsigned char dst_str[257];
1872  unsigned char iv_str[128];
1873  unsigned char add_str[128];
1874  unsigned char tag_str[128];
1875  unsigned char output[128];
1876  gcm_context ctx;
1877  unsigned int key_len;
1878  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
1879  int ret;
1880 
1881  memset(key_str, 0x00, 128);
1882  memset(src_str, 0x00, 128);
1883  memset(dst_str, 0x00, 257);
1884  memset(iv_str, 0x00, 128);
1885  memset(add_str, 0x00, 128);
1886  memset(tag_str, 0x00, 128);
1887  memset(output, 0x00, 128);
1888 
1889  key_len = unhexify( key_str, "0225b73fe5fbbe52f838d873173959d8" );
1890  pt_len = unhexify( src_str, "" );
1891  iv_len = unhexify( iv_str, "02a048764f48d9aed1147ee922395bbf" );
1892  add_len = unhexify( add_str, "9b46a57b06e156c877e94c089814493ead879397dab3dfcab2db349ef387efcd0cc339a7e79131a2c580188fc7429044a465b8329d74cd8f47272a4ed32582b1c5c7e3d32341ae902ea4923dc33df8062bc24bb51a11d2ecc82f464f615041387f9c82bd2135d4e240fe56fa8a68e6a9a417e6702430a434b14d70cf02db3181" );
1893  unhexify( tag_str, "e2c2ce4022c49a95c9ac9026" );
1894 
1895  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1896  if( 0 == 0 )
1897  {
1898  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1899 
1900  if( strcmp( "FAIL", "FAIL" ) == 0 )
1901  {
1902  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1903  }
1904  else
1905  {
1906  hexify( dst_str, output, pt_len );
1907 
1908  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
1909  }
1910  }
1911  }
1912  FCT_TEST_END();
1913 
1914 
1915  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102496_2)
1916  {
1917  unsigned char key_str[128];
1918  unsigned char src_str[128];
1919  unsigned char dst_str[257];
1920  unsigned char iv_str[128];
1921  unsigned char add_str[128];
1922  unsigned char tag_str[128];
1923  unsigned char output[128];
1924  gcm_context ctx;
1925  unsigned int key_len;
1926  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
1927  int ret;
1928 
1929  memset(key_str, 0x00, 128);
1930  memset(src_str, 0x00, 128);
1931  memset(dst_str, 0x00, 257);
1932  memset(iv_str, 0x00, 128);
1933  memset(add_str, 0x00, 128);
1934  memset(tag_str, 0x00, 128);
1935  memset(output, 0x00, 128);
1936 
1937  key_len = unhexify( key_str, "89ca3771a0ef3287568b4ac036120198" );
1938  pt_len = unhexify( src_str, "" );
1939  iv_len = unhexify( iv_str, "7e83d2ffa8af8c554cfd71a0db56ef5b" );
1940  add_len = unhexify( add_str, "1bd7a9d6262882bd12c62bd50942965b3cdcadf5e0fab2dc4d0daf0ee4b16e92c6e2464c0caa423cdce88e4d843490609716ec5e44c41672c656ac0e444d3622557ea8420c94deae3ad190ddaf859f6f8c23e4e2e32a46d28df23de4f99bd6c34f69e06eddfdfa5f263dbe8baf9d4296b2c543e4c4847271e7590374edf46234" );
1941  unhexify( tag_str, "06b2bf62591dc7ec1b814705" );
1942 
1943  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1944  if( 0 == 0 )
1945  {
1946  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1947 
1948  if( strcmp( "FAIL", "" ) == 0 )
1949  {
1950  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1951  }
1952  else
1953  {
1954  hexify( dst_str, output, pt_len );
1955 
1956  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
1957  }
1958  }
1959  }
1960  FCT_TEST_END();
1961 
1962 
1963  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102464_0)
1964  {
1965  unsigned char key_str[128];
1966  unsigned char src_str[128];
1967  unsigned char dst_str[257];
1968  unsigned char iv_str[128];
1969  unsigned char add_str[128];
1970  unsigned char tag_str[128];
1971  unsigned char output[128];
1972  gcm_context ctx;
1973  unsigned int key_len;
1974  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
1975  int ret;
1976 
1977  memset(key_str, 0x00, 128);
1978  memset(src_str, 0x00, 128);
1979  memset(dst_str, 0x00, 257);
1980  memset(iv_str, 0x00, 128);
1981  memset(add_str, 0x00, 128);
1982  memset(tag_str, 0x00, 128);
1983  memset(output, 0x00, 128);
1984 
1985  key_len = unhexify( key_str, "a41a297bd96e224942998fe2192934a1" );
1986  pt_len = unhexify( src_str, "" );
1987  iv_len = unhexify( iv_str, "6827f2c5a0b7ecd6bbc696abb0adf556" );
1988  add_len = unhexify( add_str, "f32041abd8543415cbac423d945dda5378a16a7e94d9ab5dbd2d32eb1c5048cc7c8e4df3ca84ec725f18c34cfdeaa7595392aabfd66d9e2f37c1165369cd806cd9d2110def6f5fad4345e5a6e2326c9300199438fcc078cd9fcf4d76872cac77fc9a0a8ac7e4d63995078a9addecf798460ff5910861b76c71bccfb6b629d722" );
1989  unhexify( tag_str, "49a4917eef61f78e" );
1990 
1991  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
1992  if( 0 == 0 )
1993  {
1994  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
1995 
1996  if( strcmp( "FAIL", "FAIL" ) == 0 )
1997  {
1998  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
1999  }
2000  else
2001  {
2002  hexify( dst_str, output, pt_len );
2003 
2004  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
2005  }
2006  }
2007  }
2008  FCT_TEST_END();
2009 
2010 
2011  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102464_1)
2012  {
2013  unsigned char key_str[128];
2014  unsigned char src_str[128];
2015  unsigned char dst_str[257];
2016  unsigned char iv_str[128];
2017  unsigned char add_str[128];
2018  unsigned char tag_str[128];
2019  unsigned char output[128];
2020  gcm_context ctx;
2021  unsigned int key_len;
2022  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
2023  int ret;
2024 
2025  memset(key_str, 0x00, 128);
2026  memset(src_str, 0x00, 128);
2027  memset(dst_str, 0x00, 257);
2028  memset(iv_str, 0x00, 128);
2029  memset(add_str, 0x00, 128);
2030  memset(tag_str, 0x00, 128);
2031  memset(output, 0x00, 128);
2032 
2033  key_len = unhexify( key_str, "a9372c058f42e0a1d019bdb528313919" );
2034  pt_len = unhexify( src_str, "" );
2035  iv_len = unhexify( iv_str, "8d03f423230c8f00a5b6b712d426a2af" );
2036  add_len = unhexify( add_str, "cfef4e70fcc1821eeccf7c7b5eb3c0c3b5f72dc762426e0bd26242f8aa68c5b716ab97eded5e5720caccc1965da603d556d8214d5828f2cf276d95bf552d47313876796221f62ccb818a6d801088755d58cfb751bfed0d5a19718d4e0f94b850e0279b3a69295d1837cba958a6cc56e7594080b9e5b954a199fdc9e54ddc8583" );
2037  unhexify( tag_str, "b82cd11cd3575c8d" );
2038 
2039  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2040  if( 0 == 0 )
2041  {
2042  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2043 
2044  if( strcmp( "FAIL", "" ) == 0 )
2045  {
2046  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2047  }
2048  else
2049  {
2050  hexify( dst_str, output, pt_len );
2051 
2052  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
2053  }
2054  }
2055  }
2056  FCT_TEST_END();
2057 
2058 
2059  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102464_2)
2060  {
2061  unsigned char key_str[128];
2062  unsigned char src_str[128];
2063  unsigned char dst_str[257];
2064  unsigned char iv_str[128];
2065  unsigned char add_str[128];
2066  unsigned char tag_str[128];
2067  unsigned char output[128];
2068  gcm_context ctx;
2069  unsigned int key_len;
2070  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
2071  int ret;
2072 
2073  memset(key_str, 0x00, 128);
2074  memset(src_str, 0x00, 128);
2075  memset(dst_str, 0x00, 257);
2076  memset(iv_str, 0x00, 128);
2077  memset(add_str, 0x00, 128);
2078  memset(tag_str, 0x00, 128);
2079  memset(output, 0x00, 128);
2080 
2081  key_len = unhexify( key_str, "6302b7338f8fa84195ad9abbacd89b4e" );
2082  pt_len = unhexify( src_str, "" );
2083  iv_len = unhexify( iv_str, "e1bed5c53547cbc85f3411fbb43bb08b" );
2084  add_len = unhexify( add_str, "bcd329c076e8da2797d50dcdcf271cecf3ce12f3c136ed746edc722f907be6133276ee099038fdc5d73eec812739c7489d4bcc275f95451b44890416e3ffe5a1b6fa3986b84eee3adad774c6feaecb1f785053eeda2cfc18953b8547866d98918dbe0a6abc168ac7d77467a367f11c284924d9d186ef64ef0fd54eacd75156d2" );
2085  unhexify( tag_str, "5222d092e9e8bd6c" );
2086 
2087  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2088  if( 0 == 0 )
2089  {
2090  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2091 
2092  if( strcmp( "FAIL", "" ) == 0 )
2093  {
2094  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2095  }
2096  else
2097  {
2098  hexify( dst_str, output, pt_len );
2099 
2100  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
2101  }
2102  }
2103  }
2104  FCT_TEST_END();
2105 
2106 
2107  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102432_0)
2108  {
2109  unsigned char key_str[128];
2110  unsigned char src_str[128];
2111  unsigned char dst_str[257];
2112  unsigned char iv_str[128];
2113  unsigned char add_str[128];
2114  unsigned char tag_str[128];
2115  unsigned char output[128];
2116  gcm_context ctx;
2117  unsigned int key_len;
2118  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
2119  int ret;
2120 
2121  memset(key_str, 0x00, 128);
2122  memset(src_str, 0x00, 128);
2123  memset(dst_str, 0x00, 257);
2124  memset(iv_str, 0x00, 128);
2125  memset(add_str, 0x00, 128);
2126  memset(tag_str, 0x00, 128);
2127  memset(output, 0x00, 128);
2128 
2129  key_len = unhexify( key_str, "78b5c28d62e4b2097873a1180bd5a3a5" );
2130  pt_len = unhexify( src_str, "" );
2131  iv_len = unhexify( iv_str, "c93902c2819ee494f0fc4b259ee65dd8" );
2132  add_len = unhexify( add_str, "e6b1192674a02083a6cf36d4ba93ba40a5331fadf63fd1eb2efa2ee9c0d8818472aaaf2b4705746011753f30f447c8f58dd34d29606daf57eadc172529837058cb78a378b19da8d63c321f550dfa256b5fd9f30e93d8f377443bfcd125f86a079a1765d2010be73d060f24eebae8d05e644688b2149bc39e18bd527bc066f2ba" );
2133  unhexify( tag_str, "eae48137" );
2134 
2135  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2136  if( 0 == 0 )
2137  {
2138  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2139 
2140  if( strcmp( "FAIL", "" ) == 0 )
2141  {
2142  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2143  }
2144  else
2145  {
2146  hexify( dst_str, output, pt_len );
2147 
2148  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
2149  }
2150  }
2151  }
2152  FCT_TEST_END();
2153 
2154 
2155  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102432_1)
2156  {
2157  unsigned char key_str[128];
2158  unsigned char src_str[128];
2159  unsigned char dst_str[257];
2160  unsigned char iv_str[128];
2161  unsigned char add_str[128];
2162  unsigned char tag_str[128];
2163  unsigned char output[128];
2164  gcm_context ctx;
2165  unsigned int key_len;
2166  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
2167  int ret;
2168 
2169  memset(key_str, 0x00, 128);
2170  memset(src_str, 0x00, 128);
2171  memset(dst_str, 0x00, 257);
2172  memset(iv_str, 0x00, 128);
2173  memset(add_str, 0x00, 128);
2174  memset(tag_str, 0x00, 128);
2175  memset(output, 0x00, 128);
2176 
2177  key_len = unhexify( key_str, "3d84130578070e036c9e3df5b5509473" );
2178  pt_len = unhexify( src_str, "" );
2179  iv_len = unhexify( iv_str, "3b9b4950523a19c6866fd2b0cde541fd" );
2180  add_len = unhexify( add_str, "a764931e1b21a140c54a8619aacdb4358834987fb6e263cec525f888f9e9764c165aaa7db74f2c42273f912daeae6d72b232a872ac2c652d7cd3af3a5753f58331c11b6c866475697876dbc4c6ca0e52a00ba015ee3c3b7fb444c6e50a4b4b9bbe135fc0632d32a3f79f333d8f487771ed12522e664b9cf90e66da267f47a74d" );
2181  unhexify( tag_str, "79987692" );
2182 
2183  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2184  if( 0 == 0 )
2185  {
2186  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2187 
2188  if( strcmp( "FAIL", "" ) == 0 )
2189  {
2190  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2191  }
2192  else
2193  {
2194  hexify( dst_str, output, pt_len );
2195 
2196  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
2197  }
2198  }
2199  }
2200  FCT_TEST_END();
2201 
2202 
2203  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102432_2)
2204  {
2205  unsigned char key_str[128];
2206  unsigned char src_str[128];
2207  unsigned char dst_str[257];
2208  unsigned char iv_str[128];
2209  unsigned char add_str[128];
2210  unsigned char tag_str[128];
2211  unsigned char output[128];
2212  gcm_context ctx;
2213  unsigned int key_len;
2214  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
2215  int ret;
2216 
2217  memset(key_str, 0x00, 128);
2218  memset(src_str, 0x00, 128);
2219  memset(dst_str, 0x00, 257);
2220  memset(iv_str, 0x00, 128);
2221  memset(add_str, 0x00, 128);
2222  memset(tag_str, 0x00, 128);
2223  memset(output, 0x00, 128);
2224 
2225  key_len = unhexify( key_str, "08428605ab4742a3e8a55354d4764620" );
2226  pt_len = unhexify( src_str, "" );
2227  iv_len = unhexify( iv_str, "128f5f4a817e4af04113847a223adeb0" );
2228  add_len = unhexify( add_str, "464b484ed79d93a48e0f804e04df69d7ca10ad04ba7188d69e6549ab50503baaec67e0acba5537d1163c868fd3e350e9d0ae9123046bc76815c201a947aa4a7e4ed239ce889d4ff9c8d043877de06df5fc27cf67442b729b02e9c30287c0821ef9fa15d4cccbc53a95fa9ec3ed432ca960ebbf5a169ccada95a5bf4c7c968830" );
2229  unhexify( tag_str, "3eb3e3a2" );
2230 
2231  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2232  if( 0 == 0 )
2233  {
2234  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2235 
2236  if( strcmp( "FAIL", "" ) == 0 )
2237  {
2238  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2239  }
2240  else
2241  {
2242  hexify( dst_str, output, pt_len );
2243 
2244  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
2245  }
2246  }
2247  }
2248  FCT_TEST_END();
2249 
2250 
2251  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240128_0)
2252  {
2253  unsigned char key_str[128];
2254  unsigned char src_str[128];
2255  unsigned char dst_str[257];
2256  unsigned char iv_str[128];
2257  unsigned char add_str[128];
2258  unsigned char tag_str[128];
2259  unsigned char output[128];
2260  gcm_context ctx;
2261  unsigned int key_len;
2262  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
2263  int ret;
2264 
2265  memset(key_str, 0x00, 128);
2266  memset(src_str, 0x00, 128);
2267  memset(dst_str, 0x00, 257);
2268  memset(iv_str, 0x00, 128);
2269  memset(add_str, 0x00, 128);
2270  memset(tag_str, 0x00, 128);
2271  memset(output, 0x00, 128);
2272 
2273  key_len = unhexify( key_str, "0dd358bc3f992f26e81e3a2f3aa2d517" );
2274  pt_len = unhexify( src_str, "87cc4fd75788c9d5cc83bae5d764dd249d178ab23224049795d4288b5ed9ea3f317068a39a7574b300c8544226e87b08e008fbe241d094545c211d56ac44437d41491a438272738968c8d371aa7787b5f606c8549a9d868d8a71380e9657d3c0337979feb01de5991fc1470dfc59eb02511efbbff3fcb479a862ba3844a25aaa" );
2275  iv_len = unhexify( iv_str, "d8c750bb443ee1a169dfe97cfe4d855b" );
2276  add_len = unhexify( add_str, "" );
2277  unhexify( tag_str, "a81d13973baa22a751833d7d3f94b3b1" );
2278 
2279  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2280  if( 0 == 0 )
2281  {
2282  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2283 
2284  if( strcmp( "FAIL", "77949b29f085bb3abb71a5386003811233056d3296eb093370f7777dadd306d93d59dcb9754d3857cf2758091ba661f845ef0582f6ae0e134328106f0d5d16b541cd74fdc756dc7b53f4f8a194daeea9369ebb1630c01ccb307b848e9527da20a39898d748fd59206f0b79d0ed946a8958033a45bd9ae673518b32606748eb65" ) == 0 )
2285  {
2286  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2287  }
2288  else
2289  {
2290  hexify( dst_str, output, pt_len );
2291 
2292  fct_chk( strcmp( (char *) dst_str, "77949b29f085bb3abb71a5386003811233056d3296eb093370f7777dadd306d93d59dcb9754d3857cf2758091ba661f845ef0582f6ae0e134328106f0d5d16b541cd74fdc756dc7b53f4f8a194daeea9369ebb1630c01ccb307b848e9527da20a39898d748fd59206f0b79d0ed946a8958033a45bd9ae673518b32606748eb65" ) == 0 );
2293  }
2294  }
2295  }
2296  FCT_TEST_END();
2297 
2298 
2299  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240128_1)
2300  {
2301  unsigned char key_str[128];
2302  unsigned char src_str[128];
2303  unsigned char dst_str[257];
2304  unsigned char iv_str[128];
2305  unsigned char add_str[128];
2306  unsigned char tag_str[128];
2307  unsigned char output[128];
2308  gcm_context ctx;
2309  unsigned int key_len;
2310  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
2311  int ret;
2312 
2313  memset(key_str, 0x00, 128);
2314  memset(src_str, 0x00, 128);
2315  memset(dst_str, 0x00, 257);
2316  memset(iv_str, 0x00, 128);
2317  memset(add_str, 0x00, 128);
2318  memset(tag_str, 0x00, 128);
2319  memset(output, 0x00, 128);
2320 
2321  key_len = unhexify( key_str, "43b5f18227e5c74288dbeff03801acd6" );
2322  pt_len = unhexify( src_str, "f58d630f10cfca61d4644d4f6505bab629e8e8faf1673e64417f9b79e622966a7011cfb3ff74db5cebf09ad3f41643d4437d213204a6c8397e7d59b8a5b1970aed2b6bb5ea1933c72c351f6ba96c0b0b98188f6e373f5db6c5ebece911ec7a1848abd3ae335515c774e0027dab7d1c07d047d3b8825ff94222dbaf6f9ab597ee" );
2323  iv_len = unhexify( iv_str, "08ee12246cf7edb81da3d610f3ebd167" );
2324  add_len = unhexify( add_str, "" );
2325  unhexify( tag_str, "82d83b2f7da218d1d1441a5b37bcb065" );
2326 
2327  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2328  if( 0 == 0 )
2329  {
2330  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2331 
2332  if( strcmp( "FAIL", "FAIL" ) == 0 )
2333  {
2334  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2335  }
2336  else
2337  {
2338  hexify( dst_str, output, pt_len );
2339 
2340  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
2341  }
2342  }
2343  }
2344  FCT_TEST_END();
2345 
2346 
2347  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240128_2)
2348  {
2349  unsigned char key_str[128];
2350  unsigned char src_str[128];
2351  unsigned char dst_str[257];
2352  unsigned char iv_str[128];
2353  unsigned char add_str[128];
2354  unsigned char tag_str[128];
2355  unsigned char output[128];
2356  gcm_context ctx;
2357  unsigned int key_len;
2358  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
2359  int ret;
2360 
2361  memset(key_str, 0x00, 128);
2362  memset(src_str, 0x00, 128);
2363  memset(dst_str, 0x00, 257);
2364  memset(iv_str, 0x00, 128);
2365  memset(add_str, 0x00, 128);
2366  memset(tag_str, 0x00, 128);
2367  memset(output, 0x00, 128);
2368 
2369  key_len = unhexify( key_str, "9a433c612d7e1bdff881e4d63ba8b141" );
2370  pt_len = unhexify( src_str, "ce10758332f423228b5e4ae31efda7677586934a1d8f05d9b7a0dc4e2010ec3eaacb71a527a5fff8e787d75ebd24ad163394c891b33477ed9e2a2d853c364cb1c5d0bc317fcaf4010817dbe5f1fd1037c701b291b3a66b164bc818bf5c00a4c210a1671faa574d74c7f3543f6c09aaf117e12e2eb3dae55edb1cc5b4086b617d" );
2371  iv_len = unhexify( iv_str, "8b670cf31f470f79a6c0b79e73863ca1" );
2372  add_len = unhexify( add_str, "" );
2373  unhexify( tag_str, "8526fd25daf890e79946a205b698f287" );
2374 
2375  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2376  if( 0 == 0 )
2377  {
2378  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2379 
2380  if( strcmp( "FAIL", "FAIL" ) == 0 )
2381  {
2382  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2383  }
2384  else
2385  {
2386  hexify( dst_str, output, pt_len );
2387 
2388  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
2389  }
2390  }
2391  }
2392  FCT_TEST_END();
2393 
2394 
2395  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240120_0)
2396  {
2397  unsigned char key_str[128];
2398  unsigned char src_str[128];
2399  unsigned char dst_str[257];
2400  unsigned char iv_str[128];
2401  unsigned char add_str[128];
2402  unsigned char tag_str[128];
2403  unsigned char output[128];
2404  gcm_context ctx;
2405  unsigned int key_len;
2406  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
2407  int ret;
2408 
2409  memset(key_str, 0x00, 128);
2410  memset(src_str, 0x00, 128);
2411  memset(dst_str, 0x00, 257);
2412  memset(iv_str, 0x00, 128);
2413  memset(add_str, 0x00, 128);
2414  memset(tag_str, 0x00, 128);
2415  memset(output, 0x00, 128);
2416 
2417  key_len = unhexify( key_str, "8e9d75c781d63b29f1816859f7a0e0a0" );
2418  pt_len = unhexify( src_str, "a9f1883f58e4ef78377992101ab86da0dafcefa827904dd94dff6f6704b1e45517165a34c5555a55b04c6992fb6d0840a71bd262fe59815e5c7b80fe803b47d5ba44982a3f72cb42f591d8b62df38c9f56a5868af8f68242e3a15f97be8ef2399dbace1273f509623b6f9e4d27a97436aebf2d044e75f1c62694db77ceac05de" );
2419  iv_len = unhexify( iv_str, "748a3b486b62a164cedcf1bab9325add" );
2420  add_len = unhexify( add_str, "" );
2421  unhexify( tag_str, "131e0e4ce46d768674a7bcacdcef9c" );
2422 
2423  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2424  if( 0 == 0 )
2425  {
2426  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2427 
2428  if( strcmp( "FAIL", "FAIL" ) == 0 )
2429  {
2430  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2431  }
2432  else
2433  {
2434  hexify( dst_str, output, pt_len );
2435 
2436  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
2437  }
2438  }
2439  }
2440  FCT_TEST_END();
2441 
2442 
2443  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240120_1)
2444  {
2445  unsigned char key_str[128];
2446  unsigned char src_str[128];
2447  unsigned char dst_str[257];
2448  unsigned char iv_str[128];
2449  unsigned char add_str[128];
2450  unsigned char tag_str[128];
2451  unsigned char output[128];
2452  gcm_context ctx;
2453  unsigned int key_len;
2454  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
2455  int ret;
2456 
2457  memset(key_str, 0x00, 128);
2458  memset(src_str, 0x00, 128);
2459  memset(dst_str, 0x00, 257);
2460  memset(iv_str, 0x00, 128);
2461  memset(add_str, 0x00, 128);
2462  memset(tag_str, 0x00, 128);
2463  memset(output, 0x00, 128);
2464 
2465  key_len = unhexify( key_str, "fe6b8553002c69396d9976bb48d30779" );
2466  pt_len = unhexify( src_str, "786f4801b16de7a4931ab143b269c7acc68f1ed9b17a95e8929ccec7d53413059fd4267bedbf079d9d69e90314c1345bc9cb9132f1af69323157ddf7533ced42b4b7bd39004f14d326f5b03bc19084d231d93bcab328312d99b426c1e86e8e049d380bb492e2e32ad690af4cf86838d89a0dfdcbc30e8c9e9039e423a234e113" );
2467  iv_len = unhexify( iv_str, "595b17d0d76b83780235f5e0c92bd21f" );
2468  add_len = unhexify( add_str, "" );
2469  unhexify( tag_str, "8879de07815a88877b0623de9be411" );
2470 
2471  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2472  if( 0 == 0 )
2473  {
2474  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2475 
2476  if( strcmp( "FAIL", "b15dc7cd44adcb0783f30f592e5e03ccd47851725af9fe45bfc5b01ae35779b9a8b3f26fec468b188ec3cad40785c608d6bfd867b0ccf07a836ec20d2d9b8451636df153a32b637e7dcdbd606603d9e53f6e4c4cc8396286ce64b0ea638c10e5a567c0bc8e808080b71be51381e051336e60bf1663f6d2d7640a575e0752553b" ) == 0 )
2477  {
2478  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2479  }
2480  else
2481  {
2482  hexify( dst_str, output, pt_len );
2483 
2484  fct_chk( strcmp( (char *) dst_str, "b15dc7cd44adcb0783f30f592e5e03ccd47851725af9fe45bfc5b01ae35779b9a8b3f26fec468b188ec3cad40785c608d6bfd867b0ccf07a836ec20d2d9b8451636df153a32b637e7dcdbd606603d9e53f6e4c4cc8396286ce64b0ea638c10e5a567c0bc8e808080b71be51381e051336e60bf1663f6d2d7640a575e0752553b" ) == 0 );
2485  }
2486  }
2487  }
2488  FCT_TEST_END();
2489 
2490 
2491  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240120_2)
2492  {
2493  unsigned char key_str[128];
2494  unsigned char src_str[128];
2495  unsigned char dst_str[257];
2496  unsigned char iv_str[128];
2497  unsigned char add_str[128];
2498  unsigned char tag_str[128];
2499  unsigned char output[128];
2500  gcm_context ctx;
2501  unsigned int key_len;
2502  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
2503  int ret;
2504 
2505  memset(key_str, 0x00, 128);
2506  memset(src_str, 0x00, 128);
2507  memset(dst_str, 0x00, 257);
2508  memset(iv_str, 0x00, 128);
2509  memset(add_str, 0x00, 128);
2510  memset(tag_str, 0x00, 128);
2511  memset(output, 0x00, 128);
2512 
2513  key_len = unhexify( key_str, "14898c56009b459172fef9c17993b54f" );
2514  pt_len = unhexify( src_str, "e7ba6ef722273238b975d551f95d3e77e9b75b24c547b86eafb457d409803bdf6e1443839d8604ee497020e1a3dbd687a819b17fdde0fcf240ce2129792792a58bfcd825773001ee959bf9ec8d228e27ce1cd93d7fb86769a3793361b6f82bf7daf284afc1ece657a1ee6346ea9294880755b9b623563ad2657ba2286488a2ef" );
2515  iv_len = unhexify( iv_str, "0862f8f87289988711a877d3231d44eb" );
2516  add_len = unhexify( add_str, "" );
2517  unhexify( tag_str, "36938974301ae733760f83439437c4" );
2518 
2519  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2520  if( 0 == 0 )
2521  {
2522  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2523 
2524  if( strcmp( "FAIL", "3fd56897a62743e0ab4a465bcc9777d5fd21ad2c9a59d7e4e1a60feccdc722b9820ec65cb47e1d1160d12ff2ea93abe11bc101b82514ead7d542007fee7b4e2dd6822849cd3e82d761ff7cf5ce4f40ad9fec54050a632a401451b426812cf03c2b16a8667a88bb3f7497e3308a91de6fd646d6a3562c92c24272411229a90802" ) == 0 )
2525  {
2526  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2527  }
2528  else
2529  {
2530  hexify( dst_str, output, pt_len );
2531 
2532  fct_chk( strcmp( (char *) dst_str, "3fd56897a62743e0ab4a465bcc9777d5fd21ad2c9a59d7e4e1a60feccdc722b9820ec65cb47e1d1160d12ff2ea93abe11bc101b82514ead7d542007fee7b4e2dd6822849cd3e82d761ff7cf5ce4f40ad9fec54050a632a401451b426812cf03c2b16a8667a88bb3f7497e3308a91de6fd646d6a3562c92c24272411229a90802" ) == 0 );
2533  }
2534  }
2535  }
2536  FCT_TEST_END();
2537 
2538 
2539  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240112_0)
2540  {
2541  unsigned char key_str[128];
2542  unsigned char src_str[128];
2543  unsigned char dst_str[257];
2544  unsigned char iv_str[128];
2545  unsigned char add_str[128];
2546  unsigned char tag_str[128];
2547  unsigned char output[128];
2548  gcm_context ctx;
2549  unsigned int key_len;
2550  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
2551  int ret;
2552 
2553  memset(key_str, 0x00, 128);
2554  memset(src_str, 0x00, 128);
2555  memset(dst_str, 0x00, 257);
2556  memset(iv_str, 0x00, 128);
2557  memset(add_str, 0x00, 128);
2558  memset(tag_str, 0x00, 128);
2559  memset(output, 0x00, 128);
2560 
2561  key_len = unhexify( key_str, "fe5253d4b071793b081ebc122cc2a5f8" );
2562  pt_len = unhexify( src_str, "b57a0bd7714ae95e77fa9452e11a7ed4a2bec60f81ad6ddb956d4b1cb5dfc277dcb4034d501801b26733b5e08c710c3cfdccc1b208dc7a92cd7ebe166320582bcaff64cc943c36fbe7008f004e5db70c40de05fa68b0c9d4c16c8f976130f20702b99674cd2f4c93aeaeb3abca4b1114dbc3a4b33e1226ad801aa0e21f7cc49b" );
2563  iv_len = unhexify( iv_str, "49e82d86804e196421ec19ddc8541066" );
2564  add_len = unhexify( add_str, "" );
2565  unhexify( tag_str, "e8b8ae34f842277fe92729e891e3" );
2566 
2567  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2568  if( 0 == 0 )
2569  {
2570  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2571 
2572  if( strcmp( "FAIL", "c4a31c7ec820469f895d57579f987733337ec6547d78d17c44a18fab91f0322cfe05f23f9afaf019cf9531dec2d420f3591d334f40d78643fd957b91ab588a7e392447bd702652017ede7fb0d61d444a3b3cc4136e1d4df13d9532eb71bcf3ff0ae65e847e1c572a2f90632362bc424da2249b36a84be2c2bb216ae7708f745c" ) == 0 )
2573  {
2574  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2575  }
2576  else
2577  {
2578  hexify( dst_str, output, pt_len );
2579 
2580  fct_chk( strcmp( (char *) dst_str, "c4a31c7ec820469f895d57579f987733337ec6547d78d17c44a18fab91f0322cfe05f23f9afaf019cf9531dec2d420f3591d334f40d78643fd957b91ab588a7e392447bd702652017ede7fb0d61d444a3b3cc4136e1d4df13d9532eb71bcf3ff0ae65e847e1c572a2f90632362bc424da2249b36a84be2c2bb216ae7708f745c" ) == 0 );
2581  }
2582  }
2583  }
2584  FCT_TEST_END();
2585 
2586 
2587  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240112_1)
2588  {
2589  unsigned char key_str[128];
2590  unsigned char src_str[128];
2591  unsigned char dst_str[257];
2592  unsigned char iv_str[128];
2593  unsigned char add_str[128];
2594  unsigned char tag_str[128];
2595  unsigned char output[128];
2596  gcm_context ctx;
2597  unsigned int key_len;
2598  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
2599  int ret;
2600 
2601  memset(key_str, 0x00, 128);
2602  memset(src_str, 0x00, 128);
2603  memset(dst_str, 0x00, 257);
2604  memset(iv_str, 0x00, 128);
2605  memset(add_str, 0x00, 128);
2606  memset(tag_str, 0x00, 128);
2607  memset(output, 0x00, 128);
2608 
2609  key_len = unhexify( key_str, "b3502d6f0d172246e16503cdf5793296" );
2610  pt_len = unhexify( src_str, "09268b8046f1558794e35cdc4945b94227a176dd8cb77f92f883542b1c4be698c379541fd1d557c2a07c7206afdd49506d6a1559123de1783c7a60006df06d87f9119fb105e9b278eb93f81fd316b6fdc38ef702a2b9feaa878a0d1ea999db4c593438f32e0f849f3adabf277a161afb5c1c3460039156eec78944d5666c2563" );
2611  iv_len = unhexify( iv_str, "6ce994689ff72f9df62f386a187c1a13" );
2612  add_len = unhexify( add_str, "" );
2613  unhexify( tag_str, "21cdf44ff4993eb54b55d58e5a8f" );
2614 
2615  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2616  if( 0 == 0 )
2617  {
2618  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2619 
2620  if( strcmp( "FAIL", "FAIL" ) == 0 )
2621  {
2622  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2623  }
2624  else
2625  {
2626  hexify( dst_str, output, pt_len );
2627 
2628  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
2629  }
2630  }
2631  }
2632  FCT_TEST_END();
2633 
2634 
2635  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240112_2)
2636  {
2637  unsigned char key_str[128];
2638  unsigned char src_str[128];
2639  unsigned char dst_str[257];
2640  unsigned char iv_str[128];
2641  unsigned char add_str[128];
2642  unsigned char tag_str[128];
2643  unsigned char output[128];
2644  gcm_context ctx;
2645  unsigned int key_len;
2646  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
2647  int ret;
2648 
2649  memset(key_str, 0x00, 128);
2650  memset(src_str, 0x00, 128);
2651  memset(dst_str, 0x00, 257);
2652  memset(iv_str, 0x00, 128);
2653  memset(add_str, 0x00, 128);
2654  memset(tag_str, 0x00, 128);
2655  memset(output, 0x00, 128);
2656 
2657  key_len = unhexify( key_str, "5fb33dd73db309b9dfd3aee605cd94bf" );
2658  pt_len = unhexify( src_str, "f4e011f8c99038c46854b427475f23488077ebf051c4b705a1adfdd493a0a10af7a7e9453965b94f52f61ae62ce9243a82a2dbf9c5a285db3fe34ed34ed08b5926f34c48171195f7062d02a6e6e795322a0475017371cb8f645cdcac94afc66dc43e7583bdf1c25790f4235076a53de6c64f3bc5004e5a9ce4783fbf639fad97" );
2659  iv_len = unhexify( iv_str, "3f6486f9e9e645292e0e425bac232268" );
2660  add_len = unhexify( add_str, "" );
2661  unhexify( tag_str, "7ee5e0e2082b18d09abf141f902e" );
2662 
2663  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2664  if( 0 == 0 )
2665  {
2666  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2667 
2668  if( strcmp( "FAIL", "0503cb531f1c967dae24f16dd651d544988a732020134896a0f109222e8639bf29ff69877c6ef4ac3df1b260842f909384e3d4409b99a47112681c4b17430041ca447a903a6c1b138f0efbb3b850d8290fceac9723a32edbf8e2d6e8143b1cbc7bf2d28d1b6c7f341a69918758cc82bbab5d898fa0f572d4ceaa11234cb511ec" ) == 0 )
2669  {
2670  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2671  }
2672  else
2673  {
2674  hexify( dst_str, output, pt_len );
2675 
2676  fct_chk( strcmp( (char *) dst_str, "0503cb531f1c967dae24f16dd651d544988a732020134896a0f109222e8639bf29ff69877c6ef4ac3df1b260842f909384e3d4409b99a47112681c4b17430041ca447a903a6c1b138f0efbb3b850d8290fceac9723a32edbf8e2d6e8143b1cbc7bf2d28d1b6c7f341a69918758cc82bbab5d898fa0f572d4ceaa11234cb511ec" ) == 0 );
2677  }
2678  }
2679  }
2680  FCT_TEST_END();
2681 
2682 
2683  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240104_0)
2684  {
2685  unsigned char key_str[128];
2686  unsigned char src_str[128];
2687  unsigned char dst_str[257];
2688  unsigned char iv_str[128];
2689  unsigned char add_str[128];
2690  unsigned char tag_str[128];
2691  unsigned char output[128];
2692  gcm_context ctx;
2693  unsigned int key_len;
2694  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
2695  int ret;
2696 
2697  memset(key_str, 0x00, 128);
2698  memset(src_str, 0x00, 128);
2699  memset(dst_str, 0x00, 257);
2700  memset(iv_str, 0x00, 128);
2701  memset(add_str, 0x00, 128);
2702  memset(tag_str, 0x00, 128);
2703  memset(output, 0x00, 128);
2704 
2705  key_len = unhexify( key_str, "a958fe3b520081b638d9e4c7d5da7ac7" );
2706  pt_len = unhexify( src_str, "dfa9487378c7d8af9c8dbd9e533cd81503d9e4e7dab43133bad11fd3050a53a833df9cc3208af1a86110567d311d5fc54b0d627de433c381b10e113898203ac5225140f951cdb64c6494592b6453f9b6f952ec5ece732fb46c09a324f26b27cdad63588006bb5c6c00b9aa10d5d3b2f9eaab69beeddd6f93966654f964260018" );
2707  iv_len = unhexify( iv_str, "c396109e96afde6f685d3c38aa3c2fae" );
2708  add_len = unhexify( add_str, "" );
2709  unhexify( tag_str, "06ca91004be43cf46ed4599e23" );
2710 
2711  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2712  if( 0 == 0 )
2713  {
2714  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2715 
2716  if( strcmp( "FAIL", "FAIL" ) == 0 )
2717  {
2718  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2719  }
2720  else
2721  {
2722  hexify( dst_str, output, pt_len );
2723 
2724  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
2725  }
2726  }
2727  }
2728  FCT_TEST_END();
2729 
2730 
2731  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240104_1)
2732  {
2733  unsigned char key_str[128];
2734  unsigned char src_str[128];
2735  unsigned char dst_str[257];
2736  unsigned char iv_str[128];
2737  unsigned char add_str[128];
2738  unsigned char tag_str[128];
2739  unsigned char output[128];
2740  gcm_context ctx;
2741  unsigned int key_len;
2742  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
2743  int ret;
2744 
2745  memset(key_str, 0x00, 128);
2746  memset(src_str, 0x00, 128);
2747  memset(dst_str, 0x00, 257);
2748  memset(iv_str, 0x00, 128);
2749  memset(add_str, 0x00, 128);
2750  memset(tag_str, 0x00, 128);
2751  memset(output, 0x00, 128);
2752 
2753  key_len = unhexify( key_str, "ec319fb143eac8215b51541daec268f2" );
2754  pt_len = unhexify( src_str, "d298d988e74927736237eb8ab09d7a86b854fa2fd1f7f3be83b417ac10aa9291f4af5b3fbaf75a296ac32369ad57ded3984b84711953e477de3035ba430a30ffb84c941936e6c8d2cae8d80159876f87dd682747f2dccc36d7c32ab227032b8ac70b313fa4202ea236e3ec4d9e4d8b48cf3b90b378edc5b1dbeec929549344f8" );
2755  iv_len = unhexify( iv_str, "8a4684f42a1775b03806574f401cff78" );
2756  add_len = unhexify( add_str, "" );
2757  unhexify( tag_str, "e91acb1bfda191630b560debc9" );
2758 
2759  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2760  if( 0 == 0 )
2761  {
2762  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2763 
2764  if( strcmp( "FAIL", "27ce4a622959930f4059f247d29d1438257093cc973bf1bae4e0515da88b9a7e21ec59c7e4d062035cdf88b91254d856b11c8c1944865fa12922227ded3eecccaa36341ecf5405c708e9ea173f1e6cdf090499d3bb079910771080814607a1efe62ec6835dc0333d19dd39dd9ea9f31cd3632128536149a122050bb9365b521d" ) == 0 )
2765  {
2766  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2767  }
2768  else
2769  {
2770  hexify( dst_str, output, pt_len );
2771 
2772  fct_chk( strcmp( (char *) dst_str, "27ce4a622959930f4059f247d29d1438257093cc973bf1bae4e0515da88b9a7e21ec59c7e4d062035cdf88b91254d856b11c8c1944865fa12922227ded3eecccaa36341ecf5405c708e9ea173f1e6cdf090499d3bb079910771080814607a1efe62ec6835dc0333d19dd39dd9ea9f31cd3632128536149a122050bb9365b521d" ) == 0 );
2773  }
2774  }
2775  }
2776  FCT_TEST_END();
2777 
2778 
2779  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240104_2)
2780  {
2781  unsigned char key_str[128];
2782  unsigned char src_str[128];
2783  unsigned char dst_str[257];
2784  unsigned char iv_str[128];
2785  unsigned char add_str[128];
2786  unsigned char tag_str[128];
2787  unsigned char output[128];
2788  gcm_context ctx;
2789  unsigned int key_len;
2790  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
2791  int ret;
2792 
2793  memset(key_str, 0x00, 128);
2794  memset(src_str, 0x00, 128);
2795  memset(dst_str, 0x00, 257);
2796  memset(iv_str, 0x00, 128);
2797  memset(add_str, 0x00, 128);
2798  memset(tag_str, 0x00, 128);
2799  memset(output, 0x00, 128);
2800 
2801  key_len = unhexify( key_str, "14a3e69f351ac39b4297749a90c1365c" );
2802  pt_len = unhexify( src_str, "051224f7b208549dcfda5f9d56ce5f0a072ef1f23f3810c693516c92622be6ed4d7a9e0f9450980ba490b2e9e3468ea7eef10bc9ebd673d91f32b748c1bf2c50cc4ebb59fc409c6d780bba00700d563ce1dc9927a6c860095a42ed053f3d640debfbfa7a4e6d5de234af19755000d95e7f414f1f78285ee165410c020038286b" );
2803  iv_len = unhexify( iv_str, "eb1c6c04437aa5a32bcc208bb3c01724" );
2804  add_len = unhexify( add_str, "" );
2805  unhexify( tag_str, "e418815960559aefee8e0c3831" );
2806 
2807  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2808  if( 0 == 0 )
2809  {
2810  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2811 
2812  if( strcmp( "FAIL", "797310a6ed9ce47cdc25f7f88f5dbbf6f8f4837701704d7afced250585922744598d6f95ba2eecf86e030cc5ee71b328fc1c4f2d4df945d1b91a2803d6ae8eba6881be5fe0f298dd0c0279e12720ede60b9e857ccca5abe9b4d7ee7f25108beebbfe33f05c0d9903bf613c2e7ed6a87b71b5e386d81b3ae53efd01055bbcccc2" ) == 0 )
2813  {
2814  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2815  }
2816  else
2817  {
2818  hexify( dst_str, output, pt_len );
2819 
2820  fct_chk( strcmp( (char *) dst_str, "797310a6ed9ce47cdc25f7f88f5dbbf6f8f4837701704d7afced250585922744598d6f95ba2eecf86e030cc5ee71b328fc1c4f2d4df945d1b91a2803d6ae8eba6881be5fe0f298dd0c0279e12720ede60b9e857ccca5abe9b4d7ee7f25108beebbfe33f05c0d9903bf613c2e7ed6a87b71b5e386d81b3ae53efd01055bbcccc2" ) == 0 );
2821  }
2822  }
2823  }
2824  FCT_TEST_END();
2825 
2826 
2827  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024096_0)
2828  {
2829  unsigned char key_str[128];
2830  unsigned char src_str[128];
2831  unsigned char dst_str[257];
2832  unsigned char iv_str[128];
2833  unsigned char add_str[128];
2834  unsigned char tag_str[128];
2835  unsigned char output[128];
2836  gcm_context ctx;
2837  unsigned int key_len;
2838  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
2839  int ret;
2840 
2841  memset(key_str, 0x00, 128);
2842  memset(src_str, 0x00, 128);
2843  memset(dst_str, 0x00, 257);
2844  memset(iv_str, 0x00, 128);
2845  memset(add_str, 0x00, 128);
2846  memset(tag_str, 0x00, 128);
2847  memset(output, 0x00, 128);
2848 
2849  key_len = unhexify( key_str, "c34827771fc3918d1cee09ba9401b832" );
2850  pt_len = unhexify( src_str, "ce79701b661066e53191c9acdaf677ad41622314898d7216e3f113e2e6e215d26d8bd139827f06ab3ea5c4105694e87db1dd6cec10e1f86a8744d4c541f08e40319e22ab42fc1a6c89edfd486b6f142c6bbbf84a73912e0b2e55b79db306ccabf839855afdd889e52ae981520c89e7dc29bb2adb1906cca8c93fcb21290a095b" );
2851  iv_len = unhexify( iv_str, "2379bbd39a1c22bc93b9b9cc45f3840b" );
2852  add_len = unhexify( add_str, "" );
2853  unhexify( tag_str, "26e1f6cf0d9e0f36dfd669eb" );
2854 
2855  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2856  if( 0 == 0 )
2857  {
2858  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2859 
2860  if( strcmp( "FAIL", "FAIL" ) == 0 )
2861  {
2862  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2863  }
2864  else
2865  {
2866  hexify( dst_str, output, pt_len );
2867 
2868  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
2869  }
2870  }
2871  }
2872  FCT_TEST_END();
2873 
2874 
2875  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024096_1)
2876  {
2877  unsigned char key_str[128];
2878  unsigned char src_str[128];
2879  unsigned char dst_str[257];
2880  unsigned char iv_str[128];
2881  unsigned char add_str[128];
2882  unsigned char tag_str[128];
2883  unsigned char output[128];
2884  gcm_context ctx;
2885  unsigned int key_len;
2886  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
2887  int ret;
2888 
2889  memset(key_str, 0x00, 128);
2890  memset(src_str, 0x00, 128);
2891  memset(dst_str, 0x00, 257);
2892  memset(iv_str, 0x00, 128);
2893  memset(add_str, 0x00, 128);
2894  memset(tag_str, 0x00, 128);
2895  memset(output, 0x00, 128);
2896 
2897  key_len = unhexify( key_str, "b1f9bd2006ec550b7b9913d383200b5d" );
2898  pt_len = unhexify( src_str, "6d9fc8f586d50d6e0128172ae147844e80136905d3a297497a9566ca7c7445029028f14c9950acee92a5c12a9150f5e024e01c7505dd83937542b0b1288de9c292ae8ad918a09b2edf8493540b74c73d2794f2eb6eed18eba520ddea9567462c83330f33d7892fcde0b10c73a4e26ab1bef037cec7e0190b95188e9a752fee6f" );
2899  iv_len = unhexify( iv_str, "ca28fa6b64bb3b32ef7d211f1c8be759" );
2900  add_len = unhexify( add_str, "" );
2901  unhexify( tag_str, "c87aac7ad0e85dbb103c0733" );
2902 
2903  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2904  if( 0 == 0 )
2905  {
2906  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2907 
2908  if( strcmp( "FAIL", "FAIL" ) == 0 )
2909  {
2910  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2911  }
2912  else
2913  {
2914  hexify( dst_str, output, pt_len );
2915 
2916  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
2917  }
2918  }
2919  }
2920  FCT_TEST_END();
2921 
2922 
2923  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024096_2)
2924  {
2925  unsigned char key_str[128];
2926  unsigned char src_str[128];
2927  unsigned char dst_str[257];
2928  unsigned char iv_str[128];
2929  unsigned char add_str[128];
2930  unsigned char tag_str[128];
2931  unsigned char output[128];
2932  gcm_context ctx;
2933  unsigned int key_len;
2934  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
2935  int ret;
2936 
2937  memset(key_str, 0x00, 128);
2938  memset(src_str, 0x00, 128);
2939  memset(dst_str, 0x00, 257);
2940  memset(iv_str, 0x00, 128);
2941  memset(add_str, 0x00, 128);
2942  memset(tag_str, 0x00, 128);
2943  memset(output, 0x00, 128);
2944 
2945  key_len = unhexify( key_str, "8b2cef1a92aa0af2b00fb2a99855d5bc" );
2946  pt_len = unhexify( src_str, "fd09525ef3c65ab5823e1b6c36b4a9449a3975c5d3a9e7e33c61fb32edcbb8e8c915b6202e3fbce87d73cc3b66d83d9ea7e1e353cc7468f08626932cf0235563e2a28953ee5a0afadb1c3cb513b1f1fc9a8a6cf326174b877448672f7731dd6430a51619da1a169ab302da5af5b38802f8bbf5890b5d9b45deda799679501dc4" );
2947  iv_len = unhexify( iv_str, "08d87b7acee87d884667f6b1e32e34d0" );
2948  add_len = unhexify( add_str, "" );
2949  unhexify( tag_str, "3bd7685318010b0c5fe3308b" );
2950 
2951  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
2952  if( 0 == 0 )
2953  {
2954  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
2955 
2956  if( strcmp( "FAIL", "583e64631c218549923e8ad33b728d07f23b0f19d2aff1ad7e20d564c591db0e117caa8f21e3f3345e3d84f0ccbb27274cddf9274410fc342cb2a5d4aea4e925d0dd5350389ee0dea23a842ff3f5c1198374a96f41e055f999cfbc2f47ceaa883da8eb6ff729f583eff1f91bd3f3254d4e81e60d9993b3455e67f405708e4422" ) == 0 )
2957  {
2958  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
2959  }
2960  else
2961  {
2962  hexify( dst_str, output, pt_len );
2963 
2964  fct_chk( strcmp( (char *) dst_str, "583e64631c218549923e8ad33b728d07f23b0f19d2aff1ad7e20d564c591db0e117caa8f21e3f3345e3d84f0ccbb27274cddf9274410fc342cb2a5d4aea4e925d0dd5350389ee0dea23a842ff3f5c1198374a96f41e055f999cfbc2f47ceaa883da8eb6ff729f583eff1f91bd3f3254d4e81e60d9993b3455e67f405708e4422" ) == 0 );
2965  }
2966  }
2967  }
2968  FCT_TEST_END();
2969 
2970 
2971  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024064_0)
2972  {
2973  unsigned char key_str[128];
2974  unsigned char src_str[128];
2975  unsigned char dst_str[257];
2976  unsigned char iv_str[128];
2977  unsigned char add_str[128];
2978  unsigned char tag_str[128];
2979  unsigned char output[128];
2980  gcm_context ctx;
2981  unsigned int key_len;
2982  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
2983  int ret;
2984 
2985  memset(key_str, 0x00, 128);
2986  memset(src_str, 0x00, 128);
2987  memset(dst_str, 0x00, 257);
2988  memset(iv_str, 0x00, 128);
2989  memset(add_str, 0x00, 128);
2990  memset(tag_str, 0x00, 128);
2991  memset(output, 0x00, 128);
2992 
2993  key_len = unhexify( key_str, "175c306f8644b0c4b894ae3d0971505e" );
2994  pt_len = unhexify( src_str, "fbe7ced7048f83e3a075661c4924eb77da1b4d6019d504afb942d728b31fd3b17557bd101c08453540a5e28d3505aeb8801a448afac2d9f68d20c0a31c7ef22bd95438851789eef1bebe8d96ac29607025b7e1366fecd3690ba90c315528dc435d9a786d36a16808d4b3e2c7c5175a1279792f1daccf51b2f91ac839465bb89a" );
2995  iv_len = unhexify( iv_str, "9860268ca2e10974f3726a0e5b9b310f" );
2996  add_len = unhexify( add_str, "" );
2997  unhexify( tag_str, "f809105e5fc5b13c" );
2998 
2999  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3000  if( 0 == 0 )
3001  {
3002  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3003 
3004  if( strcmp( "FAIL", "FAIL" ) == 0 )
3005  {
3006  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3007  }
3008  else
3009  {
3010  hexify( dst_str, output, pt_len );
3011 
3012  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3013  }
3014  }
3015  }
3016  FCT_TEST_END();
3017 
3018 
3019  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024064_1)
3020  {
3021  unsigned char key_str[128];
3022  unsigned char src_str[128];
3023  unsigned char dst_str[257];
3024  unsigned char iv_str[128];
3025  unsigned char add_str[128];
3026  unsigned char tag_str[128];
3027  unsigned char output[128];
3028  gcm_context ctx;
3029  unsigned int key_len;
3030  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
3031  int ret;
3032 
3033  memset(key_str, 0x00, 128);
3034  memset(src_str, 0x00, 128);
3035  memset(dst_str, 0x00, 257);
3036  memset(iv_str, 0x00, 128);
3037  memset(add_str, 0x00, 128);
3038  memset(tag_str, 0x00, 128);
3039  memset(output, 0x00, 128);
3040 
3041  key_len = unhexify( key_str, "08c0edcfe342a676ccdc04bdf854b4b0" );
3042  pt_len = unhexify( src_str, "1fc8ef8480c32d908b4bcbfa7074a38e915c20ed7a1c608422087e89442d7c5af6fe9c9a716c55793248062d8e6c6e8e904e2804da3a43701e4c78ecdb67e0b25308afc6d9b463356439cd095cff1bdf0fd91ab301c79fd257046cba79a5d5cd99f2502ad968420e4d499110106072dc687f434db0955c756a174a9024373c48" );
3043  iv_len = unhexify( iv_str, "4a7b70753930fe659f8cc38e5833f0c7" );
3044  add_len = unhexify( add_str, "" );
3045  unhexify( tag_str, "9ab1e2f3c4606376" );
3046 
3047  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3048  if( 0 == 0 )
3049  {
3050  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3051 
3052  if( strcmp( "FAIL", "983458c3f198bc685d98cea2b23cf71f0eb126e90937cab3492a46d9dc85d76bbb8035c6e209c34b2a7187df007faabe9f3064dc63f1cb15bf5a10655e39b94732e0c6583d56327e9701344e048887a81b256181cdfa9ec42ebc990875e4852240ddcb3cbc4ea4e6307075fd314f7190f3553267bd68b19e954e310ec3f8dbab" ) == 0 )
3053  {
3054  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3055  }
3056  else
3057  {
3058  hexify( dst_str, output, pt_len );
3059 
3060  fct_chk( strcmp( (char *) dst_str, "983458c3f198bc685d98cea2b23cf71f0eb126e90937cab3492a46d9dc85d76bbb8035c6e209c34b2a7187df007faabe9f3064dc63f1cb15bf5a10655e39b94732e0c6583d56327e9701344e048887a81b256181cdfa9ec42ebc990875e4852240ddcb3cbc4ea4e6307075fd314f7190f3553267bd68b19e954e310ec3f8dbab" ) == 0 );
3061  }
3062  }
3063  }
3064  FCT_TEST_END();
3065 
3066 
3067  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024064_2)
3068  {
3069  unsigned char key_str[128];
3070  unsigned char src_str[128];
3071  unsigned char dst_str[257];
3072  unsigned char iv_str[128];
3073  unsigned char add_str[128];
3074  unsigned char tag_str[128];
3075  unsigned char output[128];
3076  gcm_context ctx;
3077  unsigned int key_len;
3078  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
3079  int ret;
3080 
3081  memset(key_str, 0x00, 128);
3082  memset(src_str, 0x00, 128);
3083  memset(dst_str, 0x00, 257);
3084  memset(iv_str, 0x00, 128);
3085  memset(add_str, 0x00, 128);
3086  memset(tag_str, 0x00, 128);
3087  memset(output, 0x00, 128);
3088 
3089  key_len = unhexify( key_str, "241067a0301edf0f825d793e03383ea1" );
3090  pt_len = unhexify( src_str, "6984bb9830843529fad7f5e7760db89c778d62c764fcd2136ffb35d7d869f62f61d7fef64f65b7136398c1b5a792844528a18a13fba40b186ae08d1153b538007fc460684e2add8a9ed8dd82acbb8d357240daaa0c4deb979e54715545db03fe22e6d3906e89bdc81d535dae53075a58f65099434bfeed943dbc6024a92aa06a" );
3091  iv_len = unhexify( iv_str, "a30994261f48a66bb6c1fc3d69659228" );
3092  add_len = unhexify( add_str, "" );
3093  unhexify( tag_str, "36c3b4a732ba75ae" );
3094 
3095  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3096  if( 0 == 0 )
3097  {
3098  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3099 
3100  if( strcmp( "FAIL", "FAIL" ) == 0 )
3101  {
3102  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3103  }
3104  else
3105  {
3106  hexify( dst_str, output, pt_len );
3107 
3108  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3109  }
3110  }
3111  }
3112  FCT_TEST_END();
3113 
3114 
3115  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024032_0)
3116  {
3117  unsigned char key_str[128];
3118  unsigned char src_str[128];
3119  unsigned char dst_str[257];
3120  unsigned char iv_str[128];
3121  unsigned char add_str[128];
3122  unsigned char tag_str[128];
3123  unsigned char output[128];
3124  gcm_context ctx;
3125  unsigned int key_len;
3126  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
3127  int ret;
3128 
3129  memset(key_str, 0x00, 128);
3130  memset(src_str, 0x00, 128);
3131  memset(dst_str, 0x00, 257);
3132  memset(iv_str, 0x00, 128);
3133  memset(add_str, 0x00, 128);
3134  memset(tag_str, 0x00, 128);
3135  memset(output, 0x00, 128);
3136 
3137  key_len = unhexify( key_str, "03cccb5357bd2848332d1696f2ff90cb" );
3138  pt_len = unhexify( src_str, "5e2f18cbc1e773df9f28be08abb3d0b64d545c870c5778ac8bb396bef857d2ac1342ae1afb3bf5d64e667bf837458415d48396204fe560e3b635eb10e560e437f2d0396952998fd36e116cd047c1d7f6fc9901094454d24165c557a8816e0d0a8e0ce41e040ba6f26ca567c74fc47d9738b8cd8dae5dfc831c65bc1ba9603a07" );
3139  iv_len = unhexify( iv_str, "e0754022dfb1f813ccaf321558790806" );
3140  add_len = unhexify( add_str, "" );
3141  unhexify( tag_str, "c75f0246" );
3142 
3143  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3144  if( 0 == 0 )
3145  {
3146  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3147 
3148  if( strcmp( "FAIL", "FAIL" ) == 0 )
3149  {
3150  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3151  }
3152  else
3153  {
3154  hexify( dst_str, output, pt_len );
3155 
3156  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3157  }
3158  }
3159  }
3160  FCT_TEST_END();
3161 
3162 
3163  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024032_1)
3164  {
3165  unsigned char key_str[128];
3166  unsigned char src_str[128];
3167  unsigned char dst_str[257];
3168  unsigned char iv_str[128];
3169  unsigned char add_str[128];
3170  unsigned char tag_str[128];
3171  unsigned char output[128];
3172  gcm_context ctx;
3173  unsigned int key_len;
3174  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
3175  int ret;
3176 
3177  memset(key_str, 0x00, 128);
3178  memset(src_str, 0x00, 128);
3179  memset(dst_str, 0x00, 257);
3180  memset(iv_str, 0x00, 128);
3181  memset(add_str, 0x00, 128);
3182  memset(tag_str, 0x00, 128);
3183  memset(output, 0x00, 128);
3184 
3185  key_len = unhexify( key_str, "4e5e53c84a05d5a5348bac7b2611cf62" );
3186  pt_len = unhexify( src_str, "489c00c05dec06f282924c680f621ab99ac87f7d33ebbb4ca0eee187ec177d30d2b4afb4ee9f0dc019cf1a4da16d84b7f5f5c7fce72a32461db115b5a5a433024fd5ed3d47161836bb057a0189ed768f95e45fa967d0cc512fc91b555808c4033c945e8f2f7d36428dcb61f697e791b74e5c79b2bcb9cb81bec70d8119cd8d76" );
3187  iv_len = unhexify( iv_str, "47e40543b7d16bc9122c40b106d31d43" );
3188  add_len = unhexify( add_str, "" );
3189  unhexify( tag_str, "81eec75d" );
3190 
3191  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3192  if( 0 == 0 )
3193  {
3194  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3195 
3196  if( strcmp( "FAIL", "FAIL" ) == 0 )
3197  {
3198  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3199  }
3200  else
3201  {
3202  hexify( dst_str, output, pt_len );
3203 
3204  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3205  }
3206  }
3207  }
3208  FCT_TEST_END();
3209 
3210 
3211  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024032_2)
3212  {
3213  unsigned char key_str[128];
3214  unsigned char src_str[128];
3215  unsigned char dst_str[257];
3216  unsigned char iv_str[128];
3217  unsigned char add_str[128];
3218  unsigned char tag_str[128];
3219  unsigned char output[128];
3220  gcm_context ctx;
3221  unsigned int key_len;
3222  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
3223  int ret;
3224 
3225  memset(key_str, 0x00, 128);
3226  memset(src_str, 0x00, 128);
3227  memset(dst_str, 0x00, 257);
3228  memset(iv_str, 0x00, 128);
3229  memset(add_str, 0x00, 128);
3230  memset(tag_str, 0x00, 128);
3231  memset(output, 0x00, 128);
3232 
3233  key_len = unhexify( key_str, "2c94008bf377f90b7a1c0d2ea38f730c" );
3234  pt_len = unhexify( src_str, "7b3d619d115de9970b2df4e1f25194940b3f3da04c653231e8e6946de9dc08ae5ba37e2a93c232e1f9445f31c01333045f22bd832e3b5f9833f37070fafb0ef1c44cc5637058ab64d9e07bb81b32852d4cf749a3ddbfdb494f8de8bb4e31f46033f8a16bc22e2595d023845505ea5db74dd69ab4ca940078b09efb4ff19bdb66" );
3235  iv_len = unhexify( iv_str, "abfe92931a8411a39986b74560a38211" );
3236  add_len = unhexify( add_str, "" );
3237  unhexify( tag_str, "47d42e78" );
3238 
3239  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3240  if( 0 == 0 )
3241  {
3242  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3243 
3244  if( strcmp( "FAIL", "FAIL" ) == 0 )
3245  {
3246  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3247  }
3248  else
3249  {
3250  hexify( dst_str, output, pt_len );
3251 
3252  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3253  }
3254  }
3255  }
3256  FCT_TEST_END();
3257 
3258 
3259  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024128_0)
3260  {
3261  unsigned char key_str[128];
3262  unsigned char src_str[128];
3263  unsigned char dst_str[257];
3264  unsigned char iv_str[128];
3265  unsigned char add_str[128];
3266  unsigned char tag_str[128];
3267  unsigned char output[128];
3268  gcm_context ctx;
3269  unsigned int key_len;
3270  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
3271  int ret;
3272 
3273  memset(key_str, 0x00, 128);
3274  memset(src_str, 0x00, 128);
3275  memset(dst_str, 0x00, 257);
3276  memset(iv_str, 0x00, 128);
3277  memset(add_str, 0x00, 128);
3278  memset(tag_str, 0x00, 128);
3279  memset(output, 0x00, 128);
3280 
3281  key_len = unhexify( key_str, "69eedf3777e594c30e94e9c5e2bce467" );
3282  pt_len = unhexify( src_str, "5114e9983c96fecec3f7304ca42f52aa16cb7c6aadfb62ad537c93a3188835ca0703dad34c73cf96435b668b68a7a1d056931959316e8d3ab956bf64c4e07479c7767f9d488b0c0c351333ccf400b7e0be19a0fd173e3f2a1ae313f27e516952260fd2da9ab9daca478ebb93cd07d0b7503b32364d8e308d904d966c58f226bb" );
3283  iv_len = unhexify( iv_str, "a3330638a809ba358d6c098e4342b81e" );
3284  add_len = unhexify( add_str, "df4e3f2b47cf0e8590228fcf9913fb8a5eb9751bba318fd2d57be68c7e788e04fabf303699b99f26313d1c4956105cd2817aad21b91c28f3b9251e9c0b354490fa5abfcea0065aa3cc9b96772eb8af06a1a9054bf12d3ae698dfb01a13f989f8b8a4bb61686cf3adf58f05873a24d403a62a092290c2481e4159588fea6b9a09" );
3285  unhexify( tag_str, "5de3068e1e20eed469265000077b1db9" );
3286 
3287  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3288  if( 0 == 0 )
3289  {
3290  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3291 
3292  if( strcmp( "FAIL", "208e6321238bf5c6e2ef55a4b8f531cbbfb0d77374fe32df6dd663486cf79beeed39bb6910c3c78dd0cc30707a0a12b226b2d06024db25dcd8a4e620f009cafa5242121e864c7f3f4360aaf1e9d4e548d99615156f156008418c1c41ff2bbc007cecf8f209c73203e6df89b32871de637b3d6af2e277d146ae03f3404d387b77" ) == 0 )
3293  {
3294  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3295  }
3296  else
3297  {
3298  hexify( dst_str, output, pt_len );
3299 
3300  fct_chk( strcmp( (char *) dst_str, "208e6321238bf5c6e2ef55a4b8f531cbbfb0d77374fe32df6dd663486cf79beeed39bb6910c3c78dd0cc30707a0a12b226b2d06024db25dcd8a4e620f009cafa5242121e864c7f3f4360aaf1e9d4e548d99615156f156008418c1c41ff2bbc007cecf8f209c73203e6df89b32871de637b3d6af2e277d146ae03f3404d387b77" ) == 0 );
3301  }
3302  }
3303  }
3304  FCT_TEST_END();
3305 
3306 
3307  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024128_1)
3308  {
3309  unsigned char key_str[128];
3310  unsigned char src_str[128];
3311  unsigned char dst_str[257];
3312  unsigned char iv_str[128];
3313  unsigned char add_str[128];
3314  unsigned char tag_str[128];
3315  unsigned char output[128];
3316  gcm_context ctx;
3317  unsigned int key_len;
3318  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
3319  int ret;
3320 
3321  memset(key_str, 0x00, 128);
3322  memset(src_str, 0x00, 128);
3323  memset(dst_str, 0x00, 257);
3324  memset(iv_str, 0x00, 128);
3325  memset(add_str, 0x00, 128);
3326  memset(tag_str, 0x00, 128);
3327  memset(output, 0x00, 128);
3328 
3329  key_len = unhexify( key_str, "45cc35311eedf0ba093bf901931a7036" );
3330  pt_len = unhexify( src_str, "5dc8d7525eaad035c19714ae1b1e538cb66a4089027245351e0ad9297410fb3a0c1155407c10a8bb95a9ca624a9c9925dac003ee78926c6e90ff4ccdba10e8a78bda1c4478162a0e302de5ff05fb0f94c89c3c7429fb94828bdcd97d21333c2ee72963ee6f056ce272b8bab007e653a42b01d1d2041ba627f169c8c0d32e6dae" );
3331  iv_len = unhexify( iv_str, "fed5084de3c348f5a0adf4c2fd4e848a" );
3332  add_len = unhexify( add_str, "6e210914e4aed188d576f5ad7fc7e4cf7dd8d82f34ea3bcbdb7267cfd9045f806978dbff3460c4e8ff8c4edb6ad2edba405a8d915729d89aab2116b36a70b54f5920a97f5a571977e0329eda6c696749be940eabfc6d8b0bbd6fbdb87657b3a7695da9f5d3a7384257f20e0becd8512d3705cc246ee6ca1e610921cf92603d79" );
3333  unhexify( tag_str, "266a895fc21da5176b44b446d7d1921d" );
3334 
3335  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3336  if( 0 == 0 )
3337  {
3338  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3339 
3340  if( strcmp( "FAIL", "FAIL" ) == 0 )
3341  {
3342  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3343  }
3344  else
3345  {
3346  hexify( dst_str, output, pt_len );
3347 
3348  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3349  }
3350  }
3351  }
3352  FCT_TEST_END();
3353 
3354 
3355  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024128_2)
3356  {
3357  unsigned char key_str[128];
3358  unsigned char src_str[128];
3359  unsigned char dst_str[257];
3360  unsigned char iv_str[128];
3361  unsigned char add_str[128];
3362  unsigned char tag_str[128];
3363  unsigned char output[128];
3364  gcm_context ctx;
3365  unsigned int key_len;
3366  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
3367  int ret;
3368 
3369  memset(key_str, 0x00, 128);
3370  memset(src_str, 0x00, 128);
3371  memset(dst_str, 0x00, 257);
3372  memset(iv_str, 0x00, 128);
3373  memset(add_str, 0x00, 128);
3374  memset(tag_str, 0x00, 128);
3375  memset(output, 0x00, 128);
3376 
3377  key_len = unhexify( key_str, "9edb5231ca4a136b4df4ae22b8588f9f" );
3378  pt_len = unhexify( src_str, "493df801c57f8bb591955712d92d3fc34518f0599fec8533b2b4473364e1df4f560c12444cf50eeb584676b7e955c742189de6b50b8e012dfa6642f3679fb02bc6d8e08d1db88c8ae955a7946263e06494e17f8df246b672942661e5563302252208f2e00a0d77068a020e26082c291a75a06f63c41e2830292a418b2b5fd9dd" );
3379  iv_len = unhexify( iv_str, "c342e9bdabe7be922b2695f5894e032c" );
3380  add_len = unhexify( add_str, "a45c7f8032ac5144deef8d5380f033aea2786b0592720a867f4831eaccc6b85d3fd568aedc6e472e017455b0b5b30cf7a08ea43ca587f35e1646ecd9b4dc774d11e350c82c65692be1e9541cbd72a283bdcf93dc7115545f373747b4f8d5915ed0c42fbeefd3e9bd86003d65efc2361fde5b874ddabcf8265e6b884615102eff" );
3381  unhexify( tag_str, "5ed3ea75c8172fa0e8755fef7b4c90f1" );
3382 
3383  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3384  if( 0 == 0 )
3385  {
3386  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3387 
3388  if( strcmp( "FAIL", "56696e501fac1e8d5b83ef911ed11337d5d51ff5342a82993dd5340bb9632e6606eef68ec5fe8cec6b34ebbc596c279e6cbc9221c4cde933f6d93ae014e3c4ca49593f35eaa638606d059519bac3a3373519e6184e7227d2aa62170c36479fe239cb698bfca863925a4c9fb1338685a55a6dfd3bd9c52d8ae12be8551fce6e1a" ) == 0 )
3389  {
3390  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3391  }
3392  else
3393  {
3394  hexify( dst_str, output, pt_len );
3395 
3396  fct_chk( strcmp( (char *) dst_str, "56696e501fac1e8d5b83ef911ed11337d5d51ff5342a82993dd5340bb9632e6606eef68ec5fe8cec6b34ebbc596c279e6cbc9221c4cde933f6d93ae014e3c4ca49593f35eaa638606d059519bac3a3373519e6184e7227d2aa62170c36479fe239cb698bfca863925a4c9fb1338685a55a6dfd3bd9c52d8ae12be8551fce6e1a" ) == 0 );
3397  }
3398  }
3399  }
3400  FCT_TEST_END();
3401 
3402 
3403  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024120_0)
3404  {
3405  unsigned char key_str[128];
3406  unsigned char src_str[128];
3407  unsigned char dst_str[257];
3408  unsigned char iv_str[128];
3409  unsigned char add_str[128];
3410  unsigned char tag_str[128];
3411  unsigned char output[128];
3412  gcm_context ctx;
3413  unsigned int key_len;
3414  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
3415  int ret;
3416 
3417  memset(key_str, 0x00, 128);
3418  memset(src_str, 0x00, 128);
3419  memset(dst_str, 0x00, 257);
3420  memset(iv_str, 0x00, 128);
3421  memset(add_str, 0x00, 128);
3422  memset(tag_str, 0x00, 128);
3423  memset(output, 0x00, 128);
3424 
3425  key_len = unhexify( key_str, "d5fdcb8f5225090e63fae9b68f92c7cb" );
3426  pt_len = unhexify( src_str, "d39b9cba95e3a3aab9bc1d03ff475c04faeb5b7f0510777f39e5a05756606eb7ddd154aac035d9ddaf3535629821dd8f014dedd52cd184f52fc706e3c89a3a271398c9125d9a624dafb297a56022ca2ea331ea7359ab5e65f8e14814788e64e0a886a9b1a0144bf268fdcf9d94c3d10a0452f40111da9df108252e9039eacea3" );
3427  iv_len = unhexify( iv_str, "581c818282a0905df5ffff652e5604e9" );
3428  add_len = unhexify( add_str, "f1ae6cd7b07f261105f555cf812a1d5bf8dd9aac07666318acffa11abb77d0238156663acbf7543825b45c6e9cddb481a40995ecd78bb5f4cba5df7c7efb00fc19c7f45e94d37697aca8ef368b99165393b6107f900194c797cd3289cb097eb5915f2abfd6aa52dd1effffdde448e30075a1c053246db54b0ec16eadca1c0071" );
3429  unhexify( tag_str, "827e66b5b70dce56215cfb86c9a642" );
3430 
3431  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3432  if( 0 == 0 )
3433  {
3434  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3435 
3436  if( strcmp( "FAIL", "cec11a12e47fd443f878e8e9fe23c65f29dd2d53cec59b799bcb0928de8e2f92fe85c27cec5c842ef30967b919accafe0c0d731b57f0bb5685d90a3061cb473e50e8aeca1346d1f47f7db06941f83f21ba5976d97c28cab547d8c1f38387a04b8a0b212da55b75fbaf9562eeeabd78eadcbab66457f0cd4e0d28133a64cb063f" ) == 0 )
3437  {
3438  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3439  }
3440  else
3441  {
3442  hexify( dst_str, output, pt_len );
3443 
3444  fct_chk( strcmp( (char *) dst_str, "cec11a12e47fd443f878e8e9fe23c65f29dd2d53cec59b799bcb0928de8e2f92fe85c27cec5c842ef30967b919accafe0c0d731b57f0bb5685d90a3061cb473e50e8aeca1346d1f47f7db06941f83f21ba5976d97c28cab547d8c1f38387a04b8a0b212da55b75fbaf9562eeeabd78eadcbab66457f0cd4e0d28133a64cb063f" ) == 0 );
3445  }
3446  }
3447  }
3448  FCT_TEST_END();
3449 
3450 
3451  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024120_1)
3452  {
3453  unsigned char key_str[128];
3454  unsigned char src_str[128];
3455  unsigned char dst_str[257];
3456  unsigned char iv_str[128];
3457  unsigned char add_str[128];
3458  unsigned char tag_str[128];
3459  unsigned char output[128];
3460  gcm_context ctx;
3461  unsigned int key_len;
3462  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
3463  int ret;
3464 
3465  memset(key_str, 0x00, 128);
3466  memset(src_str, 0x00, 128);
3467  memset(dst_str, 0x00, 257);
3468  memset(iv_str, 0x00, 128);
3469  memset(add_str, 0x00, 128);
3470  memset(tag_str, 0x00, 128);
3471  memset(output, 0x00, 128);
3472 
3473  key_len = unhexify( key_str, "036198cd3a3ab9319684d0f811cf2992" );
3474  pt_len = unhexify( src_str, "6b95b9e82a695fb7b466ce3adb536f525d8314f95eada39efb49baf121093ce7d5439f0d8223e03530b85accd388a70650ca9f7e63eb32afecb7b1916ed9b762128cc641caf3e08e027c3d88481d653b6b15172e977dfb9b3f88465911aee162501cbf8501ce2b66ee151bbfdc23225f638f18750c239d62471663e5ee2a5856" );
3475  iv_len = unhexify( iv_str, "47dffc6b3b80ffef4b943bde87b9cf3c" );
3476  add_len = unhexify( add_str, "ec4de476cd337f564a3facb544d0ff31cd89af4c3d9a28543e45156189f8eff8f804494dda83a1fb2c30ce858884a01ec63db59268452b1eea0f0d48280bb7340eaacc84509469dd94d303774d053d7ab4fb5f6c26581efeb19165f8cb09d58ec314d09ab8356731e87fd081f661e7b2d1a7c3aa4af5448a12b742e7b210b0b0" );
3477  unhexify( tag_str, "6cf68a374bea08a977ec8a04b92e8b" );
3478 
3479  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3480  if( 0 == 0 )
3481  {
3482  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3483 
3484  if( strcmp( "FAIL", "5c2f7c408167be3d266ff634e1993fe291aef7efae245fa0b6b5bde886a810c866ae6a078286684d1b66116e636e285f03646e09f3c4ed7b184e7c171ba84f3bfd9500c6f35964a404892b4cdcdd3f697fc5b01934a86019810987a9fea7efca016049873f1072f62df3c17f57ea1d88ccd8757f7e3c5d96e8a18d5366a39ea9" ) == 0 )
3485  {
3486  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3487  }
3488  else
3489  {
3490  hexify( dst_str, output, pt_len );
3491 
3492  fct_chk( strcmp( (char *) dst_str, "5c2f7c408167be3d266ff634e1993fe291aef7efae245fa0b6b5bde886a810c866ae6a078286684d1b66116e636e285f03646e09f3c4ed7b184e7c171ba84f3bfd9500c6f35964a404892b4cdcdd3f697fc5b01934a86019810987a9fea7efca016049873f1072f62df3c17f57ea1d88ccd8757f7e3c5d96e8a18d5366a39ea9" ) == 0 );
3493  }
3494  }
3495  }
3496  FCT_TEST_END();
3497 
3498 
3499  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024120_2)
3500  {
3501  unsigned char key_str[128];
3502  unsigned char src_str[128];
3503  unsigned char dst_str[257];
3504  unsigned char iv_str[128];
3505  unsigned char add_str[128];
3506  unsigned char tag_str[128];
3507  unsigned char output[128];
3508  gcm_context ctx;
3509  unsigned int key_len;
3510  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
3511  int ret;
3512 
3513  memset(key_str, 0x00, 128);
3514  memset(src_str, 0x00, 128);
3515  memset(dst_str, 0x00, 257);
3516  memset(iv_str, 0x00, 128);
3517  memset(add_str, 0x00, 128);
3518  memset(tag_str, 0x00, 128);
3519  memset(output, 0x00, 128);
3520 
3521  key_len = unhexify( key_str, "c9fbbff8f25f951ba874dfc5ff38584e" );
3522  pt_len = unhexify( src_str, "ca401071396da00376add467490abc6e6a7d8a85852026979f7013a09cf689113c8d833560cd6c5b8fdaa8fdd818e773ac13954839a0a2c91efeaf4e0e14de43308419a8b86fa2ae600a88a6bd39dfaabc16a3c7c1b77a5c2aab7f7caceb2f8595324125efbb7c96ba16c47d0bd10568b24bf445d72d683268466e68e46df500" );
3523  iv_len = unhexify( iv_str, "1c1fc752673be6d4ff4cc749fc11e0fe" );
3524  add_len = unhexify( add_str, "abfde0b60acfe265b62ed68ebebc1f5f725f155c4b8a8aeec8d704701c51ff7817060c1b0ce6b80d6efc9836c9ea2bc022ec67db4cd34e945e3a1b153fd2e0f7ac84bb4b07e04cbb529ee24014b16067f9f082b940c9d5e54024d3e5e910310457478560721587da7b5343d89eec5a8fce389c01185db15e7faa9a3fa32e8ab9" );
3525  unhexify( tag_str, "ff0b2c384e03b50e7e829c7a9f95aa" );
3526 
3527  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3528  if( 0 == 0 )
3529  {
3530  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3531 
3532  if( strcmp( "FAIL", "239637fac6e180e71b2c9fa63ce8805f453d81499623ec2deba9b033350250662897867bffaf0c314244baf9e1fe3e1bb7c626d616bfbf3e0ac09a32aaf718b432337c9dc57c2d6fc4a0a09bdc05b9184d1b90c7193b7869f91e2caa8b3b35c10c6621ffae4c609bdf4e4e3f06e930541c381451ef58f4f30a559d2b79b0e6b6" ) == 0 )
3533  {
3534  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3535  }
3536  else
3537  {
3538  hexify( dst_str, output, pt_len );
3539 
3540  fct_chk( strcmp( (char *) dst_str, "239637fac6e180e71b2c9fa63ce8805f453d81499623ec2deba9b033350250662897867bffaf0c314244baf9e1fe3e1bb7c626d616bfbf3e0ac09a32aaf718b432337c9dc57c2d6fc4a0a09bdc05b9184d1b90c7193b7869f91e2caa8b3b35c10c6621ffae4c609bdf4e4e3f06e930541c381451ef58f4f30a559d2b79b0e6b6" ) == 0 );
3541  }
3542  }
3543  }
3544  FCT_TEST_END();
3545 
3546 
3547  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024112_0)
3548  {
3549  unsigned char key_str[128];
3550  unsigned char src_str[128];
3551  unsigned char dst_str[257];
3552  unsigned char iv_str[128];
3553  unsigned char add_str[128];
3554  unsigned char tag_str[128];
3555  unsigned char output[128];
3556  gcm_context ctx;
3557  unsigned int key_len;
3558  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
3559  int ret;
3560 
3561  memset(key_str, 0x00, 128);
3562  memset(src_str, 0x00, 128);
3563  memset(dst_str, 0x00, 257);
3564  memset(iv_str, 0x00, 128);
3565  memset(add_str, 0x00, 128);
3566  memset(tag_str, 0x00, 128);
3567  memset(output, 0x00, 128);
3568 
3569  key_len = unhexify( key_str, "3a314ec178da96311e42334a616fb38b" );
3570  pt_len = unhexify( src_str, "518b3f5384ab54f80497d55be7a5d6902bc7718386212c2ec7537db331514b3838f104bf9054e03039a4cfb73f41e5d0a9648e569ed738cea8d33917430dff6afa8f07a75e324b9262fa196a4439dcd66b0535ee5bea0d292600227c2a79ed03be0671740e5cb7b306d855612bd3abcbf02cf7e7cecbb6cdbb33d57b4e3234a2" );
3571  iv_len = unhexify( iv_str, "d7ea27c819e3eb2666611bb1c7fc068d" );
3572  add_len = unhexify( add_str, "db8dcc31a5681f13d56abd51bd2dcb0d2b171628186e215a68bf16167b4acd00c3441973c3fa62fa2698ee5c6749fc20e542364d63c40756d8bcff780269e5201bafdced3cdc97931d8203873431882c84522c151b775285d0a3c5d7667254c74724ff0ea9d417aa6c62835865dfded34edd331c0c235a089427672c5a9211c9" );
3573  unhexify( tag_str, "1e774647b1ca406e0ed7141a8e1e" );
3574 
3575  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3576  if( 0 == 0 )
3577  {
3578  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3579 
3580  if( strcmp( "FAIL", "FAIL" ) == 0 )
3581  {
3582  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3583  }
3584  else
3585  {
3586  hexify( dst_str, output, pt_len );
3587 
3588  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3589  }
3590  }
3591  }
3592  FCT_TEST_END();
3593 
3594 
3595  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024112_1)
3596  {
3597  unsigned char key_str[128];
3598  unsigned char src_str[128];
3599  unsigned char dst_str[257];
3600  unsigned char iv_str[128];
3601  unsigned char add_str[128];
3602  unsigned char tag_str[128];
3603  unsigned char output[128];
3604  gcm_context ctx;
3605  unsigned int key_len;
3606  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
3607  int ret;
3608 
3609  memset(key_str, 0x00, 128);
3610  memset(src_str, 0x00, 128);
3611  memset(dst_str, 0x00, 257);
3612  memset(iv_str, 0x00, 128);
3613  memset(add_str, 0x00, 128);
3614  memset(tag_str, 0x00, 128);
3615  memset(output, 0x00, 128);
3616 
3617  key_len = unhexify( key_str, "e818372a63b7e2c23b524e29ba752bdb" );
3618  pt_len = unhexify( src_str, "c1bf1b702a95ceaa6b48a1cdd888ae51f58a9fc3232bd6c784529a83301c6d0cdda6e605ad9a2563f54a8d59f624ae7c589e48b85041a010dcb6fb8739d43e79a456fc0e8574af086df78680460c3cdc4e00dc3b9d4e76b0de26e9aec546705249fa7e7466c01001c2667eaf2813be1f0f116916f34843a06b201d653aa1b27e" );
3619  iv_len = unhexify( iv_str, "36e617e787cb25e154f73af1da68cb06" );
3620  add_len = unhexify( add_str, "71801d69796c2ce36b043c157aec9fd2e06fd1ec596126d10c26b6d44e3dc36c4fa30a030d65c382b6ddfd958e71fe9c16732e595137a3d6764c15480fc3358e9a113ba492b31274663f5842df5d1cc6bad70e83b34675a4411e2e70755aede0ff5035601be130562e27a20283d6f144ff1bdb5276dec05fad80d51b28d50688" );
3621  unhexify( tag_str, "3744262bc76f283964c1c15dc069" );
3622 
3623  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3624  if( 0 == 0 )
3625  {
3626  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3627 
3628  if( strcmp( "FAIL", "FAIL" ) == 0 )
3629  {
3630  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3631  }
3632  else
3633  {
3634  hexify( dst_str, output, pt_len );
3635 
3636  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3637  }
3638  }
3639  }
3640  FCT_TEST_END();
3641 
3642 
3643  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024112_2)
3644  {
3645  unsigned char key_str[128];
3646  unsigned char src_str[128];
3647  unsigned char dst_str[257];
3648  unsigned char iv_str[128];
3649  unsigned char add_str[128];
3650  unsigned char tag_str[128];
3651  unsigned char output[128];
3652  gcm_context ctx;
3653  unsigned int key_len;
3654  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
3655  int ret;
3656 
3657  memset(key_str, 0x00, 128);
3658  memset(src_str, 0x00, 128);
3659  memset(dst_str, 0x00, 257);
3660  memset(iv_str, 0x00, 128);
3661  memset(add_str, 0x00, 128);
3662  memset(tag_str, 0x00, 128);
3663  memset(output, 0x00, 128);
3664 
3665  key_len = unhexify( key_str, "9a04f16882ff45816739d1b6697ce8b7" );
3666  pt_len = unhexify( src_str, "6a4f3dbb3371f64258fd1f831349e745a4e19a33aad794b1de3788729618beed619586092120e9e5dc3ac6e0d52f991f7be61afbfaa4399ac716ad79a2734827254b1627791dc92a128a6f43426b8085dee94242e83176a3d762658f18ecc1e37e3e1531648c9caed212ea2cf3b3843cb92cb07730f30fe2dca3925470fadd06" );
3667  iv_len = unhexify( iv_str, "66f504d9a9128ad7fb7f1430d37c4784" );
3668  add_len = unhexify( add_str, "f641c53c83c4fb1ff8044bfa97cdf63fe75d8159d65b3e5ad585b89c083a53cf4a2f7a58eaeaf45fa71f2c07bc5725a6b03307d7f32884a133a4c803700bf1e12564b98b71f63b434ddf13ad2c467dda25ffa6effcafa72452b20c34cfae71e47096f8745b487e9f1945f5bec83f7ec2709a13b504d92315b1b727a78902be84" );
3669  unhexify( tag_str, "fbb37084396394fecd9581741f3c" );
3670 
3671  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3672  if( 0 == 0 )
3673  {
3674  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3675 
3676  if( strcmp( "FAIL", "FAIL" ) == 0 )
3677  {
3678  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3679  }
3680  else
3681  {
3682  hexify( dst_str, output, pt_len );
3683 
3684  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3685  }
3686  }
3687  }
3688  FCT_TEST_END();
3689 
3690 
3691  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024104_0)
3692  {
3693  unsigned char key_str[128];
3694  unsigned char src_str[128];
3695  unsigned char dst_str[257];
3696  unsigned char iv_str[128];
3697  unsigned char add_str[128];
3698  unsigned char tag_str[128];
3699  unsigned char output[128];
3700  gcm_context ctx;
3701  unsigned int key_len;
3702  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
3703  int ret;
3704 
3705  memset(key_str, 0x00, 128);
3706  memset(src_str, 0x00, 128);
3707  memset(dst_str, 0x00, 257);
3708  memset(iv_str, 0x00, 128);
3709  memset(add_str, 0x00, 128);
3710  memset(tag_str, 0x00, 128);
3711  memset(output, 0x00, 128);
3712 
3713  key_len = unhexify( key_str, "38cf029a4b20607030586cd2d82146e6" );
3714  pt_len = unhexify( src_str, "f4c9f4476561c9ebdac71b282ae6e2f9f03547da98e66d4d857720db2fcc9ed1f363858db34c9dcaca0109d7c81db24150493115f2bb6985efa8686e3d2ab719d33b230aa4c5c70696bf42f225fb3c6704711c054a882d89b320884a78cb59cd2100496edf4010487597fb9135d8ca79693a43843e9626fd6c64a8722b3a27dc" );
3715  iv_len = unhexify( iv_str, "6330084319e2bf32cd5240f4826944bc" );
3716  add_len = unhexify( add_str, "80746cfb0127c592f8164d751b0e14a5b379056a884cece7ee4e9b80538d7ff6be56a3b19c135786722aaf315123b47672b0251e87ea45f0fd3601cf93f9efa6cbd9ad537f54d57f1e187f821faac24096ecec19d137c9f4cf145c278af4cd8de01c7758784fda06f1cc62d92ae1977786f3d0645714ab4ab6f48c8794b12f73" );
3717  unhexify( tag_str, "7b021de5cda915ba58f90ceef4" );
3718 
3719  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3720  if( 0 == 0 )
3721  {
3722  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3723 
3724  if( strcmp( "FAIL", "FAIL" ) == 0 )
3725  {
3726  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3727  }
3728  else
3729  {
3730  hexify( dst_str, output, pt_len );
3731 
3732  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3733  }
3734  }
3735  }
3736  FCT_TEST_END();
3737 
3738 
3739  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024104_1)
3740  {
3741  unsigned char key_str[128];
3742  unsigned char src_str[128];
3743  unsigned char dst_str[257];
3744  unsigned char iv_str[128];
3745  unsigned char add_str[128];
3746  unsigned char tag_str[128];
3747  unsigned char output[128];
3748  gcm_context ctx;
3749  unsigned int key_len;
3750  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
3751  int ret;
3752 
3753  memset(key_str, 0x00, 128);
3754  memset(src_str, 0x00, 128);
3755  memset(dst_str, 0x00, 257);
3756  memset(iv_str, 0x00, 128);
3757  memset(add_str, 0x00, 128);
3758  memset(tag_str, 0x00, 128);
3759  memset(output, 0x00, 128);
3760 
3761  key_len = unhexify( key_str, "cf4d81fc5997c744a572bed71f4ae609" );
3762  pt_len = unhexify( src_str, "f3d65d70326e641fbe7fd945fe9cf66c74f17d0d1020ae8ac488f39b7285c99d8632bc2201960f3d77daccfecc04428abe0853aa8d82b90a93127c72b2d2af53f7f1bd0afb99d50f0b3b24e934ec98eddb278b2c65866442cebf10208c7ce1b7ecf764858480b2a269b106fa6d2428d5ad17612e53e62ccc7ad1184663aeb9a7" );
3763  iv_len = unhexify( iv_str, "bc4e20c56931c967ce8e3b8f5f1c392f" );
3764  add_len = unhexify( add_str, "b6b8294abf7da5703f864721f7904d3821f5568bf4b269e44edef4f1c95ddc172d83a06c0ad9f7f1fd2e292c17a876392bc5bb705d370b2f16ff721bef7648f423346fd3a4d762676e6fcf2d690553a47224af29afed0f452d263be90eb8150a13d720f1db6f1abc1c2ec18cfbf93b8ed3c5aa7cfc1dcb514d69f90409687a4d" );
3765  unhexify( tag_str, "0a86142a0af81c8df64ba689f4" );
3766 
3767  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3768  if( 0 == 0 )
3769  {
3770  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3771 
3772  if( strcmp( "FAIL", "FAIL" ) == 0 )
3773  {
3774  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3775  }
3776  else
3777  {
3778  hexify( dst_str, output, pt_len );
3779 
3780  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3781  }
3782  }
3783  }
3784  FCT_TEST_END();
3785 
3786 
3787  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024104_2)
3788  {
3789  unsigned char key_str[128];
3790  unsigned char src_str[128];
3791  unsigned char dst_str[257];
3792  unsigned char iv_str[128];
3793  unsigned char add_str[128];
3794  unsigned char tag_str[128];
3795  unsigned char output[128];
3796  gcm_context ctx;
3797  unsigned int key_len;
3798  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
3799  int ret;
3800 
3801  memset(key_str, 0x00, 128);
3802  memset(src_str, 0x00, 128);
3803  memset(dst_str, 0x00, 257);
3804  memset(iv_str, 0x00, 128);
3805  memset(add_str, 0x00, 128);
3806  memset(tag_str, 0x00, 128);
3807  memset(output, 0x00, 128);
3808 
3809  key_len = unhexify( key_str, "d88ad40b42ead744f1b7a36685658be1" );
3810  pt_len = unhexify( src_str, "e99d2566fe6bcb2a04d167605db7c0f1e5567ff2d8d3292c15bbccc5d1e872bcb15a30b3bb8b1eb45e02fba15946e6bca310583a6740845a0f74f4ebfd5c59ced46875823e369e0447cc3e5d03dae530adf3c9846362c94e7f9d17207bf92d4d59981d8fd904eb8b96a0a23eb0f8d7e7a87e8e8892a2451524da6841ce575c27" );
3811  iv_len = unhexify( iv_str, "52c3158f5bd65a0a7ce1c5b57b9b295e" );
3812  add_len = unhexify( add_str, "dde2663335c40e5550ae192b843fa9fb4ef357b5c09d9f39dafda3296a4d14031817ee4dc1a201d677597d81e37050cd3dc86c25adbd551e947a080b6c47ec7be8a927ef7920bd1bb81f2c59801a2b9d745d33344cbe4838bcf2eb8dce53ab82c75c9bbab8e406597f6908aaa81fbbdef25aa69116c8f7a8cdc9958435aa32ac" );
3813  unhexify( tag_str, "7643b3534eb5cb38331ed2e572" );
3814 
3815  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3816  if( 0 == 0 )
3817  {
3818  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3819 
3820  if( strcmp( "FAIL", "6f87f6be2f4e7421aa26fe321045d1e23066a02158634bef35890581c92367d0bc232940de30974c70a66c60137a9f3924d12db1e5bc1b0e7131ea3620a25eb805b7d670263b82c8bbfcd6839305025390fc17d42d82daebe1b24f73ff9aa4617e3866785dded88f8b55ef89b2798ea2641a592a46428d9020f9bf853c194576" ) == 0 )
3821  {
3822  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3823  }
3824  else
3825  {
3826  hexify( dst_str, output, pt_len );
3827 
3828  fct_chk( strcmp( (char *) dst_str, "6f87f6be2f4e7421aa26fe321045d1e23066a02158634bef35890581c92367d0bc232940de30974c70a66c60137a9f3924d12db1e5bc1b0e7131ea3620a25eb805b7d670263b82c8bbfcd6839305025390fc17d42d82daebe1b24f73ff9aa4617e3866785dded88f8b55ef89b2798ea2641a592a46428d9020f9bf853c194576" ) == 0 );
3829  }
3830  }
3831  }
3832  FCT_TEST_END();
3833 
3834 
3835  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102496_0)
3836  {
3837  unsigned char key_str[128];
3838  unsigned char src_str[128];
3839  unsigned char dst_str[257];
3840  unsigned char iv_str[128];
3841  unsigned char add_str[128];
3842  unsigned char tag_str[128];
3843  unsigned char output[128];
3844  gcm_context ctx;
3845  unsigned int key_len;
3846  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
3847  int ret;
3848 
3849  memset(key_str, 0x00, 128);
3850  memset(src_str, 0x00, 128);
3851  memset(dst_str, 0x00, 257);
3852  memset(iv_str, 0x00, 128);
3853  memset(add_str, 0x00, 128);
3854  memset(tag_str, 0x00, 128);
3855  memset(output, 0x00, 128);
3856 
3857  key_len = unhexify( key_str, "c3ce86a212a30e724b4c624057db4e79" );
3858  pt_len = unhexify( src_str, "3582ef7a9565c9a8e4496750ee5ca3e3a80df6238f7b7608e3394ec56d1360777921da039ede34abcedd01081babd496ba4de74a7de501181d6bb2022a6cc7f79d89a4c6a97676fb0f2b42f70e2d0bc1eaac364c3646df4f611c1d6b09737451b81b5a4da73c05fb58391c74e44498b80b26f1c29562d23c39b5d3f086b280cb" );
3859  iv_len = unhexify( iv_str, "9e03f0dd4cb2b3d830a6925e4400ed89" );
3860  add_len = unhexify( add_str, "92c48a39d93ea3308f55f6650d33fdf17a902076d582a94a82ac99496de9f62312292b844bbca5a683ef0f0710bbc1c7f89cbcca8f9c0299f154590d32059bd99fca5d78c450ede0d11d55075947caf2151218ce7a06c1e81985a7781a3444054170b457fd7ba816026310112abb47c8eddfd3ab7f679a0f60efc6c6dd3b759e" );
3861  unhexify( tag_str, "3230fe94b6ccd63e605f87d0" );
3862 
3863  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3864  if( 0 == 0 )
3865  {
3866  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3867 
3868  if( strcmp( "FAIL", "052347a4273cddba65b2a0b961477f07edee440a9117ab204359d2dd45ad2a6dad3b60ead891e7da6d79f3017ac90f95725a0089f04d25ce537bf53b7ea8e1ea58692d34c221db141e2a9fd7211adcee03ef8b5bf3c5d36311d20bb3d81f70f7e7272d0e2b6d12293b1a2c31b70f140a8f08d98c6231a3c429c3d0a10b2e1c1c" ) == 0 )
3869  {
3870  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3871  }
3872  else
3873  {
3874  hexify( dst_str, output, pt_len );
3875 
3876  fct_chk( strcmp( (char *) dst_str, "052347a4273cddba65b2a0b961477f07edee440a9117ab204359d2dd45ad2a6dad3b60ead891e7da6d79f3017ac90f95725a0089f04d25ce537bf53b7ea8e1ea58692d34c221db141e2a9fd7211adcee03ef8b5bf3c5d36311d20bb3d81f70f7e7272d0e2b6d12293b1a2c31b70f140a8f08d98c6231a3c429c3d0a10b2e1c1c" ) == 0 );
3877  }
3878  }
3879  }
3880  FCT_TEST_END();
3881 
3882 
3883  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102496_1)
3884  {
3885  unsigned char key_str[128];
3886  unsigned char src_str[128];
3887  unsigned char dst_str[257];
3888  unsigned char iv_str[128];
3889  unsigned char add_str[128];
3890  unsigned char tag_str[128];
3891  unsigned char output[128];
3892  gcm_context ctx;
3893  unsigned int key_len;
3894  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
3895  int ret;
3896 
3897  memset(key_str, 0x00, 128);
3898  memset(src_str, 0x00, 128);
3899  memset(dst_str, 0x00, 257);
3900  memset(iv_str, 0x00, 128);
3901  memset(add_str, 0x00, 128);
3902  memset(tag_str, 0x00, 128);
3903  memset(output, 0x00, 128);
3904 
3905  key_len = unhexify( key_str, "a0155360b84420b5bf4fb410ea02f31e" );
3906  pt_len = unhexify( src_str, "ecdb51522fc440f7471ea6a31f7c1ef1ec2153e5bcf6303297dbf8ddb3830b45ed9866157375ce4bdeb5e32fcbc6607984fccd7e6552628736608ab13072856d432ceccd3e90d1bb52ca9ada9cee90eb89ac10e887a1978fd0fb3d7bb20caaf35539e150be8044b725b8427c4c4a910f79980865d36344a8784bcc3d58460acb" );
3907  iv_len = unhexify( iv_str, "46f0386be7363887e7e357376305eab5" );
3908  add_len = unhexify( add_str, "611bc290f91798ad84f0a5ecb5a7cb8fa35e9ab6a5a51c9869a68a076e96f92c9c117595f92cbac5d33343fa2accd2541473907cbc54792c5e215ae857424c921b04ca4b81376bbedbfcc0e565c118f2aced08f247698eed5e2d202c48245161cabeac9fa195219f9799fa253e339561e13012167f1d02b4012b7791b7c863ba" );
3909  unhexify( tag_str, "ac5addcc10cae6c1345520f1" );
3910 
3911  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3912  if( 0 == 0 )
3913  {
3914  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3915 
3916  if( strcmp( "FAIL", "FAIL" ) == 0 )
3917  {
3918  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3919  }
3920  else
3921  {
3922  hexify( dst_str, output, pt_len );
3923 
3924  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
3925  }
3926  }
3927  }
3928  FCT_TEST_END();
3929 
3930 
3931  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102496_2)
3932  {
3933  unsigned char key_str[128];
3934  unsigned char src_str[128];
3935  unsigned char dst_str[257];
3936  unsigned char iv_str[128];
3937  unsigned char add_str[128];
3938  unsigned char tag_str[128];
3939  unsigned char output[128];
3940  gcm_context ctx;
3941  unsigned int key_len;
3942  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
3943  int ret;
3944 
3945  memset(key_str, 0x00, 128);
3946  memset(src_str, 0x00, 128);
3947  memset(dst_str, 0x00, 257);
3948  memset(iv_str, 0x00, 128);
3949  memset(add_str, 0x00, 128);
3950  memset(tag_str, 0x00, 128);
3951  memset(output, 0x00, 128);
3952 
3953  key_len = unhexify( key_str, "694f621f594d96b16c32254ff06f3f9c" );
3954  pt_len = unhexify( src_str, "e61476b8b7f101ca6005f25af2b9bee795d62720bbbf59357057ca7cd473e00f0d465255fce8d6164657603323549fb4e3d33fa51054b1a70cc7e492916dea85453e9107fe781bfeb4a622c5b2306a8dddef99386dc50745003aa7220cd7f32fb0a060fa7682576769a48f9169c7d11fe0a8a61b95f5d6dfcf216f7d0c652a84" );
3955  iv_len = unhexify( iv_str, "542db4e107485a3cd24c7ad337a4f1b5" );
3956  add_len = unhexify( add_str, "27b7bfa5eb34ba376e515e58ab8b6556c396820d0074a1fe3b984945dcf5251ca450456ccb4bb66ec739b03fdc5f72d24553e843255adc012d1f1c95aa3cdac5d12926465354217203052cbd4869a8b5be2e01d0fe66b5a6a8da0a2ce351557e2991ce77baa812b9c67b8e1c5a1fc348710e1a73a0fd49acfd538b7db6bef8b3" );
3957  unhexify( tag_str, "0bdef4d771a1740381e7db97" );
3958 
3959  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
3960  if( 0 == 0 )
3961  {
3962  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
3963 
3964  if( strcmp( "FAIL", "8b27a338fd2153d304f04655e09bd9bdf4468890ecce1e3b51de2c9a25a8d9336a9acd753ce270b1fe8d50196feac68145e0fd59c9cb3aa7c1e8af03494bc4279c6e287c849f3c775ada584ae173100946ae6921ef7c96bbc6f216093548702cf1867bb1bf1f4c9e90a34230a2b2aeb584622dd615023a43a406e64428bd9170" ) == 0 )
3965  {
3966  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
3967  }
3968  else
3969  {
3970  hexify( dst_str, output, pt_len );
3971 
3972  fct_chk( strcmp( (char *) dst_str, "8b27a338fd2153d304f04655e09bd9bdf4468890ecce1e3b51de2c9a25a8d9336a9acd753ce270b1fe8d50196feac68145e0fd59c9cb3aa7c1e8af03494bc4279c6e287c849f3c775ada584ae173100946ae6921ef7c96bbc6f216093548702cf1867bb1bf1f4c9e90a34230a2b2aeb584622dd615023a43a406e64428bd9170" ) == 0 );
3973  }
3974  }
3975  }
3976  FCT_TEST_END();
3977 
3978 
3979  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102464_0)
3980  {
3981  unsigned char key_str[128];
3982  unsigned char src_str[128];
3983  unsigned char dst_str[257];
3984  unsigned char iv_str[128];
3985  unsigned char add_str[128];
3986  unsigned char tag_str[128];
3987  unsigned char output[128];
3988  gcm_context ctx;
3989  unsigned int key_len;
3990  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
3991  int ret;
3992 
3993  memset(key_str, 0x00, 128);
3994  memset(src_str, 0x00, 128);
3995  memset(dst_str, 0x00, 257);
3996  memset(iv_str, 0x00, 128);
3997  memset(add_str, 0x00, 128);
3998  memset(tag_str, 0x00, 128);
3999  memset(output, 0x00, 128);
4000 
4001  key_len = unhexify( key_str, "78826a5215a1d5e1b39cad5a06861f8f" );
4002  pt_len = unhexify( src_str, "0fe2c798d7015d3e2f8725648d95729c45d357dc0c89fc63b9df5a68d3e65419540f663e9190793a29c58c495d5c6a731782acf119e2df8a96fb180ad772c301d098dbc5e3560ac45b6631a01cef7eed6db51f223775d601d2e11b9baa55e2f0651344777e5a03f6738a2013626a891b5f134f07b16598b8cbe3aeaefa1c2a26" );
4003  iv_len = unhexify( iv_str, "feb9d740fd1e221e328b5ef5ed19eff5" );
4004  add_len = unhexify( add_str, "ca9411b368d8295210d7a04da05a351d287f2f67d978ef1bb936de9f8065473f6fa11495da2eab13a1002231c86411d5409bbc718e2042ee99e013b1df1ef786e9fc1f2d43293c854128184efb9317c4ef82a002eac8b28fcd91d8a714a3aa25fc3c0ae4af9f4bcf5ad19a30cd8ec4b1785df70aa92074da419abe433dd4c435" );
4005  unhexify( tag_str, "a724bbb295a02883" );
4006 
4007  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4008  if( 0 == 0 )
4009  {
4010  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4011 
4012  if( strcmp( "FAIL", "FAIL" ) == 0 )
4013  {
4014  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4015  }
4016  else
4017  {
4018  hexify( dst_str, output, pt_len );
4019 
4020  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4021  }
4022  }
4023  }
4024  FCT_TEST_END();
4025 
4026 
4027  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102464_1)
4028  {
4029  unsigned char key_str[128];
4030  unsigned char src_str[128];
4031  unsigned char dst_str[257];
4032  unsigned char iv_str[128];
4033  unsigned char add_str[128];
4034  unsigned char tag_str[128];
4035  unsigned char output[128];
4036  gcm_context ctx;
4037  unsigned int key_len;
4038  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
4039  int ret;
4040 
4041  memset(key_str, 0x00, 128);
4042  memset(src_str, 0x00, 128);
4043  memset(dst_str, 0x00, 257);
4044  memset(iv_str, 0x00, 128);
4045  memset(add_str, 0x00, 128);
4046  memset(tag_str, 0x00, 128);
4047  memset(output, 0x00, 128);
4048 
4049  key_len = unhexify( key_str, "d450f5253251121606e56687952bf2f1" );
4050  pt_len = unhexify( src_str, "479b4f421bd8ac7f615c4a507da187cb5d4b1f1e2c6113d1f9678c1ba92dc5e17c5b525d7f3208733223eb82af0820b8476e9b08ca714ce044417b24d2238720cb8ffdc69db558cbaff52e3651b400e16c9d5ac8ed8949a19c35516f80394a04bd1cfdced7b204f779d792086e00b2ebca2f55a1140e85f5ee9ac7cfc5a31747" );
4051  iv_len = unhexify( iv_str, "fe7ff90b020fc77d7fcd90bc583850ac" );
4052  add_len = unhexify( add_str, "a3bca9ff25a60006eb18f993dcdc99681e414e27605264dfd25652195d7fe1489550afd07fc7346b88d93b59eb6642913646e93bf50ee1db5dd30106cf181124d8ad01c72ed99038c9798620abdf5c78c419b08c97f982b34d9e9105d9aa4538afcd37f62e2412f14f7a248fcd60abaf2b66cd4554767f99030f1a495d56a5ae" );
4053  unhexify( tag_str, "6446398aff73ed23" );
4054 
4055  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4056  if( 0 == 0 )
4057  {
4058  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4059 
4060  if( strcmp( "FAIL", "FAIL" ) == 0 )
4061  {
4062  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4063  }
4064  else
4065  {
4066  hexify( dst_str, output, pt_len );
4067 
4068  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4069  }
4070  }
4071  }
4072  FCT_TEST_END();
4073 
4074 
4075  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102464_2)
4076  {
4077  unsigned char key_str[128];
4078  unsigned char src_str[128];
4079  unsigned char dst_str[257];
4080  unsigned char iv_str[128];
4081  unsigned char add_str[128];
4082  unsigned char tag_str[128];
4083  unsigned char output[128];
4084  gcm_context ctx;
4085  unsigned int key_len;
4086  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
4087  int ret;
4088 
4089  memset(key_str, 0x00, 128);
4090  memset(src_str, 0x00, 128);
4091  memset(dst_str, 0x00, 257);
4092  memset(iv_str, 0x00, 128);
4093  memset(add_str, 0x00, 128);
4094  memset(tag_str, 0x00, 128);
4095  memset(output, 0x00, 128);
4096 
4097  key_len = unhexify( key_str, "90a59f6b0abf932311f0b65623c17740" );
4098  pt_len = unhexify( src_str, "be5a948a771a8df12adaf74d702f064a75f6483c03203365fbde7d184844fe6dee0b84cf344be05b1d163817ba1516fcb87b9167ed81f884ada73b0058e2b38cba515bbbe462f4c21f8de1d41bca2cf4340aa659f9f07886c2bb620d9c3295318c07fa3c17fe8242409359c08bcb337e5cf268880839b6a20f4ee4b3f04e7024" );
4099  iv_len = unhexify( iv_str, "20778bea82a6717038e7064f48a31981" );
4100  add_len = unhexify( add_str, "4022d04f1454a72d2efe57533bd32757595220b20f3a37d166cec0412fb1eb2588f939ecd906c805f4827338669888e9f730905001eb1b136b95e306edf70d9ba1e5cd0aa13a25a1f28ab55cff36f9cd7036c735e3b285d26002ad2ed1074b566e252ea3ec8a9ce10882375dc3f1d9676e301dcb179eaae991120b796cc35648" );
4101  unhexify( tag_str, "dc77c1d7e0902d48" );
4102 
4103  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4104  if( 0 == 0 )
4105  {
4106  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4107 
4108  if( strcmp( "FAIL", "FAIL" ) == 0 )
4109  {
4110  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4111  }
4112  else
4113  {
4114  hexify( dst_str, output, pt_len );
4115 
4116  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4117  }
4118  }
4119  }
4120  FCT_TEST_END();
4121 
4122 
4123  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102432_0)
4124  {
4125  unsigned char key_str[128];
4126  unsigned char src_str[128];
4127  unsigned char dst_str[257];
4128  unsigned char iv_str[128];
4129  unsigned char add_str[128];
4130  unsigned char tag_str[128];
4131  unsigned char output[128];
4132  gcm_context ctx;
4133  unsigned int key_len;
4134  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
4135  int ret;
4136 
4137  memset(key_str, 0x00, 128);
4138  memset(src_str, 0x00, 128);
4139  memset(dst_str, 0x00, 257);
4140  memset(iv_str, 0x00, 128);
4141  memset(add_str, 0x00, 128);
4142  memset(tag_str, 0x00, 128);
4143  memset(output, 0x00, 128);
4144 
4145  key_len = unhexify( key_str, "6be4ef629f0b38194c74f7b66418922d" );
4146  pt_len = unhexify( src_str, "b67ea20a320f4ec0e4185c62a4ad79a3c97a8189a5e4d1deff9d3edff0f9a9323532853c1a2a2c1e62e4d1afebfcdf1d8461921ea601750380e63b912d8b7389198f976851d88a19f1aa32c97143668ad00838d98da1c4f2be0e6e2dc964d170d7f7ad2e2997982e5ca110e744b6e10c24ca18eadff6b129b1f290c8a7e0a593" );
4147  iv_len = unhexify( iv_str, "fb77a4b9b246271abfc656433f87628c" );
4148  add_len = unhexify( add_str, "e5d5227725a19a3050fbf2a97a6e854bc1218b94a4a3403b721ace3447daff68fff5553a26edd41219e68fb61fb9e964d0a3c29796251ae4eb942187cdc55d13a09dfb487e93d9e2072d7271456a77c6ccb81154443eea176314d6e3a08619b52cd880f1c28ae5214ac0090a3855dbd74f87389fe8afebd464330fb683dff81a" );
4149  unhexify( tag_str, "3d8fc6fb" );
4150 
4151  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4152  if( 0 == 0 )
4153  {
4154  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4155 
4156  if( strcmp( "FAIL", "FAIL" ) == 0 )
4157  {
4158  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4159  }
4160  else
4161  {
4162  hexify( dst_str, output, pt_len );
4163 
4164  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4165  }
4166  }
4167  }
4168  FCT_TEST_END();
4169 
4170 
4171  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102432_1)
4172  {
4173  unsigned char key_str[128];
4174  unsigned char src_str[128];
4175  unsigned char dst_str[257];
4176  unsigned char iv_str[128];
4177  unsigned char add_str[128];
4178  unsigned char tag_str[128];
4179  unsigned char output[128];
4180  gcm_context ctx;
4181  unsigned int key_len;
4182  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
4183  int ret;
4184 
4185  memset(key_str, 0x00, 128);
4186  memset(src_str, 0x00, 128);
4187  memset(dst_str, 0x00, 257);
4188  memset(iv_str, 0x00, 128);
4189  memset(add_str, 0x00, 128);
4190  memset(tag_str, 0x00, 128);
4191  memset(output, 0x00, 128);
4192 
4193  key_len = unhexify( key_str, "c50e37244931e8debc12b3d561c83ba2" );
4194  pt_len = unhexify( src_str, "b9abf0796f2d2f774735546cf809030f65ed0c7f6bd469ef2fe0ef32aa0225b57fbce07c36017bbc1806a81ff1a429278160a07643f864485b4e0e35d57553dc1a131e32aa10f1f91d663b10f0a418f472ed7b4bca54fd7ffdbb22c4d7764d94a7ffd04730614459431eb64335b9b65363de292c04275d40a7b968c0f5c486e9" );
4195  iv_len = unhexify( iv_str, "6c0b1fd7ab424a6883c36457d1b5521f" );
4196  add_len = unhexify( add_str, "516dc25f6452ae169ce293c5cee440de47353ca5ba770dca0f04175950e87a2d4c3f84fbc6eeacaac436853492929680066f959e74de4b736ab924d8367b90aaa6e9492561ad4b5aa78b6737d562e960edc3b983e2e01a186e9f22896f48d8dfcfb6a42cfe2c6006c687a27772820a1e8875bdf09e8104248ce4db883376bc04" );
4197  unhexify( tag_str, "7d4393f0" );
4198 
4199  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4200  if( 0 == 0 )
4201  {
4202  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4203 
4204  if( strcmp( "FAIL", "962509e494f10269b70ebad02b0cd799d1d41191a734863ef502aff3d3ba48dc2acf9da9a3fc3f40be4d210dc5e128bc00499aec57aa0a4669863165428687b88d46fad41e36af8ea6605586eaa5c0736d0d53b9d523e0cb5a0b285048e060a73cbf4b587d2cd787debdb2b4c8cda731a61a15b19fe8b561fbdd3a7373853ae1" ) == 0 )
4205  {
4206  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4207  }
4208  else
4209  {
4210  hexify( dst_str, output, pt_len );
4211 
4212  fct_chk( strcmp( (char *) dst_str, "962509e494f10269b70ebad02b0cd799d1d41191a734863ef502aff3d3ba48dc2acf9da9a3fc3f40be4d210dc5e128bc00499aec57aa0a4669863165428687b88d46fad41e36af8ea6605586eaa5c0736d0d53b9d523e0cb5a0b285048e060a73cbf4b587d2cd787debdb2b4c8cda731a61a15b19fe8b561fbdd3a7373853ae1" ) == 0 );
4213  }
4214  }
4215  }
4216  FCT_TEST_END();
4217 
4218 
4219  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102432_2)
4220  {
4221  unsigned char key_str[128];
4222  unsigned char src_str[128];
4223  unsigned char dst_str[257];
4224  unsigned char iv_str[128];
4225  unsigned char add_str[128];
4226  unsigned char tag_str[128];
4227  unsigned char output[128];
4228  gcm_context ctx;
4229  unsigned int key_len;
4230  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
4231  int ret;
4232 
4233  memset(key_str, 0x00, 128);
4234  memset(src_str, 0x00, 128);
4235  memset(dst_str, 0x00, 257);
4236  memset(iv_str, 0x00, 128);
4237  memset(add_str, 0x00, 128);
4238  memset(tag_str, 0x00, 128);
4239  memset(output, 0x00, 128);
4240 
4241  key_len = unhexify( key_str, "8531ddb03977383405baf2ee9ca7d64b" );
4242  pt_len = unhexify( src_str, "d90c9e26509bdba9b1dea8d2b94f2b1881d22c2bd756ad23cd61944710a1c1f2807170ed47a6870ae654e44757fcb3822ef28b37946cafc07284f8a0c22ae3552954f0d87b8d8c825bd546935b494cacb4262d9e2a88f254f200ad31367d8b3715afbabea5f34214ffedb14d7c84806022aba2dc8f88a314ffbb24017d1a9b9f" );
4243  iv_len = unhexify( iv_str, "baf623867d6a25fd85d1f08e599c0566" );
4244  add_len = unhexify( add_str, "18f92cdd37dcd7f99b06838f3f68748aba367baabaebd0da9ee787d70e752fa07dea553a43b643b8d8f460175c0746675205e20a7a98acfcac864d7c4cf5ab4c41c031738c76882acda003c5af47b1c4df8894a827a317935d970d4afaee17715c9cfd1883e8c345f19d1f89e229b8edba6b4f53b86d8da1c0f159afb83b6b33" );
4245  unhexify( tag_str, "2fc9de46" );
4246 
4247  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4248  if( 0 == 0 )
4249  {
4250  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4251 
4252  if( strcmp( "FAIL", "FAIL" ) == 0 )
4253  {
4254  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4255  }
4256  else
4257  {
4258  hexify( dst_str, output, pt_len );
4259 
4260  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4261  }
4262  }
4263  }
4264  FCT_TEST_END();
4265 
4266 
4267  FCT_TEST_BGN(gcm_nist_validation_aes_12812800128_0)
4268  {
4269  unsigned char key_str[128];
4270  unsigned char src_str[128];
4271  unsigned char dst_str[257];
4272  unsigned char iv_str[128];
4273  unsigned char add_str[128];
4274  unsigned char tag_str[128];
4275  unsigned char output[128];
4276  gcm_context ctx;
4277  unsigned int key_len;
4278  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
4279  int ret;
4280 
4281  memset(key_str, 0x00, 128);
4282  memset(src_str, 0x00, 128);
4283  memset(dst_str, 0x00, 257);
4284  memset(iv_str, 0x00, 128);
4285  memset(add_str, 0x00, 128);
4286  memset(tag_str, 0x00, 128);
4287  memset(output, 0x00, 128);
4288 
4289  key_len = unhexify( key_str, "862dd5b362cfa556ca37e73cff7f4a0e" );
4290  pt_len = unhexify( src_str, "" );
4291  iv_len = unhexify( iv_str, "81530a243655a60d22d9ab40d2520447" );
4292  add_len = unhexify( add_str, "" );
4293  unhexify( tag_str, "3b9b2af54e610ed0b3dda96961dd8783" );
4294 
4295  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4296  if( 0 == 0 )
4297  {
4298  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4299 
4300  if( strcmp( "FAIL", "" ) == 0 )
4301  {
4302  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4303  }
4304  else
4305  {
4306  hexify( dst_str, output, pt_len );
4307 
4308  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4309  }
4310  }
4311  }
4312  FCT_TEST_END();
4313 
4314 
4315  FCT_TEST_BGN(gcm_nist_validation_aes_12812800128_1)
4316  {
4317  unsigned char key_str[128];
4318  unsigned char src_str[128];
4319  unsigned char dst_str[257];
4320  unsigned char iv_str[128];
4321  unsigned char add_str[128];
4322  unsigned char tag_str[128];
4323  unsigned char output[128];
4324  gcm_context ctx;
4325  unsigned int key_len;
4326  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
4327  int ret;
4328 
4329  memset(key_str, 0x00, 128);
4330  memset(src_str, 0x00, 128);
4331  memset(dst_str, 0x00, 257);
4332  memset(iv_str, 0x00, 128);
4333  memset(add_str, 0x00, 128);
4334  memset(tag_str, 0x00, 128);
4335  memset(output, 0x00, 128);
4336 
4337  key_len = unhexify( key_str, "3452b7bc100c334292e08343f139b9d0" );
4338  pt_len = unhexify( src_str, "" );
4339  iv_len = unhexify( iv_str, "8f92739a30fe4ba24079f5d42753d6ac" );
4340  add_len = unhexify( add_str, "" );
4341  unhexify( tag_str, "0eeca69f8b95e1a902cc3ab1aaa8e2af" );
4342 
4343  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4344  if( 0 == 0 )
4345  {
4346  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4347 
4348  if( strcmp( "FAIL", "" ) == 0 )
4349  {
4350  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4351  }
4352  else
4353  {
4354  hexify( dst_str, output, pt_len );
4355 
4356  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4357  }
4358  }
4359  }
4360  FCT_TEST_END();
4361 
4362 
4363  FCT_TEST_BGN(gcm_nist_validation_aes_12812800128_2)
4364  {
4365  unsigned char key_str[128];
4366  unsigned char src_str[128];
4367  unsigned char dst_str[257];
4368  unsigned char iv_str[128];
4369  unsigned char add_str[128];
4370  unsigned char tag_str[128];
4371  unsigned char output[128];
4372  gcm_context ctx;
4373  unsigned int key_len;
4374  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
4375  int ret;
4376 
4377  memset(key_str, 0x00, 128);
4378  memset(src_str, 0x00, 128);
4379  memset(dst_str, 0x00, 257);
4380  memset(iv_str, 0x00, 128);
4381  memset(add_str, 0x00, 128);
4382  memset(tag_str, 0x00, 128);
4383  memset(output, 0x00, 128);
4384 
4385  key_len = unhexify( key_str, "31a0cbaf21b943f8badc939e94eac7eb" );
4386  pt_len = unhexify( src_str, "" );
4387  iv_len = unhexify( iv_str, "d5bb2c4eaec47088230972ae34fcda9c" );
4388  add_len = unhexify( add_str, "" );
4389  unhexify( tag_str, "580e728512c8e44fbb3fe2c498e05323" );
4390 
4391  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4392  if( 0 == 0 )
4393  {
4394  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4395 
4396  if( strcmp( "FAIL", "" ) == 0 )
4397  {
4398  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4399  }
4400  else
4401  {
4402  hexify( dst_str, output, pt_len );
4403 
4404  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4405  }
4406  }
4407  }
4408  FCT_TEST_END();
4409 
4410 
4411  FCT_TEST_BGN(gcm_nist_validation_aes_12812800120_0)
4412  {
4413  unsigned char key_str[128];
4414  unsigned char src_str[128];
4415  unsigned char dst_str[257];
4416  unsigned char iv_str[128];
4417  unsigned char add_str[128];
4418  unsigned char tag_str[128];
4419  unsigned char output[128];
4420  gcm_context ctx;
4421  unsigned int key_len;
4422  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
4423  int ret;
4424 
4425  memset(key_str, 0x00, 128);
4426  memset(src_str, 0x00, 128);
4427  memset(dst_str, 0x00, 257);
4428  memset(iv_str, 0x00, 128);
4429  memset(add_str, 0x00, 128);
4430  memset(tag_str, 0x00, 128);
4431  memset(output, 0x00, 128);
4432 
4433  key_len = unhexify( key_str, "9e8fca537746e7cbff97f1dcd40a3392" );
4434  pt_len = unhexify( src_str, "" );
4435  iv_len = unhexify( iv_str, "43e9f2bf186b2af8cc022e7c7412d641" );
4436  add_len = unhexify( add_str, "" );
4437  unhexify( tag_str, "4465a3f9d9751789bcef5c7c58cbc5" );
4438 
4439  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4440  if( 0 == 0 )
4441  {
4442  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4443 
4444  if( strcmp( "FAIL", "" ) == 0 )
4445  {
4446  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4447  }
4448  else
4449  {
4450  hexify( dst_str, output, pt_len );
4451 
4452  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4453  }
4454  }
4455  }
4456  FCT_TEST_END();
4457 
4458 
4459  FCT_TEST_BGN(gcm_nist_validation_aes_12812800120_1)
4460  {
4461  unsigned char key_str[128];
4462  unsigned char src_str[128];
4463  unsigned char dst_str[257];
4464  unsigned char iv_str[128];
4465  unsigned char add_str[128];
4466  unsigned char tag_str[128];
4467  unsigned char output[128];
4468  gcm_context ctx;
4469  unsigned int key_len;
4470  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
4471  int ret;
4472 
4473  memset(key_str, 0x00, 128);
4474  memset(src_str, 0x00, 128);
4475  memset(dst_str, 0x00, 257);
4476  memset(iv_str, 0x00, 128);
4477  memset(add_str, 0x00, 128);
4478  memset(tag_str, 0x00, 128);
4479  memset(output, 0x00, 128);
4480 
4481  key_len = unhexify( key_str, "35b5854ca83792ad691dbda1a66790fb" );
4482  pt_len = unhexify( src_str, "" );
4483  iv_len = unhexify( iv_str, "cff61cf9b32ea30cf7e3692aa6e74bed" );
4484  add_len = unhexify( add_str, "" );
4485  unhexify( tag_str, "726793199df533dd9055b0ac7c939d" );
4486 
4487  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4488  if( 0 == 0 )
4489  {
4490  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4491 
4492  if( strcmp( "FAIL", "" ) == 0 )
4493  {
4494  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4495  }
4496  else
4497  {
4498  hexify( dst_str, output, pt_len );
4499 
4500  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4501  }
4502  }
4503  }
4504  FCT_TEST_END();
4505 
4506 
4507  FCT_TEST_BGN(gcm_nist_validation_aes_12812800120_2)
4508  {
4509  unsigned char key_str[128];
4510  unsigned char src_str[128];
4511  unsigned char dst_str[257];
4512  unsigned char iv_str[128];
4513  unsigned char add_str[128];
4514  unsigned char tag_str[128];
4515  unsigned char output[128];
4516  gcm_context ctx;
4517  unsigned int key_len;
4518  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
4519  int ret;
4520 
4521  memset(key_str, 0x00, 128);
4522  memset(src_str, 0x00, 128);
4523  memset(dst_str, 0x00, 257);
4524  memset(iv_str, 0x00, 128);
4525  memset(add_str, 0x00, 128);
4526  memset(tag_str, 0x00, 128);
4527  memset(output, 0x00, 128);
4528 
4529  key_len = unhexify( key_str, "07259267c1c6a015437a5d8cfa92f9e6" );
4530  pt_len = unhexify( src_str, "" );
4531  iv_len = unhexify( iv_str, "18b9cf2ad7ace6ec1c8366b72878cf20" );
4532  add_len = unhexify( add_str, "" );
4533  unhexify( tag_str, "4340f6263f0ba2d82c2eb79cb0cc7e" );
4534 
4535  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4536  if( 0 == 0 )
4537  {
4538  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4539 
4540  if( strcmp( "FAIL", "" ) == 0 )
4541  {
4542  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4543  }
4544  else
4545  {
4546  hexify( dst_str, output, pt_len );
4547 
4548  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4549  }
4550  }
4551  }
4552  FCT_TEST_END();
4553 
4554 
4555  FCT_TEST_BGN(gcm_nist_validation_aes_12812800112_0)
4556  {
4557  unsigned char key_str[128];
4558  unsigned char src_str[128];
4559  unsigned char dst_str[257];
4560  unsigned char iv_str[128];
4561  unsigned char add_str[128];
4562  unsigned char tag_str[128];
4563  unsigned char output[128];
4564  gcm_context ctx;
4565  unsigned int key_len;
4566  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
4567  int ret;
4568 
4569  memset(key_str, 0x00, 128);
4570  memset(src_str, 0x00, 128);
4571  memset(dst_str, 0x00, 257);
4572  memset(iv_str, 0x00, 128);
4573  memset(add_str, 0x00, 128);
4574  memset(tag_str, 0x00, 128);
4575  memset(output, 0x00, 128);
4576 
4577  key_len = unhexify( key_str, "fa1df8955aa3ef191900b06e7c1b7d46" );
4578  pt_len = unhexify( src_str, "" );
4579  iv_len = unhexify( iv_str, "6928c138c98a4350c318fbdccd3f44ba" );
4580  add_len = unhexify( add_str, "" );
4581  unhexify( tag_str, "7c89d9e77515d271b6ed54c9c4e3" );
4582 
4583  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4584  if( 0 == 0 )
4585  {
4586  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4587 
4588  if( strcmp( "FAIL", "FAIL" ) == 0 )
4589  {
4590  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4591  }
4592  else
4593  {
4594  hexify( dst_str, output, pt_len );
4595 
4596  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4597  }
4598  }
4599  }
4600  FCT_TEST_END();
4601 
4602 
4603  FCT_TEST_BGN(gcm_nist_validation_aes_12812800112_1)
4604  {
4605  unsigned char key_str[128];
4606  unsigned char src_str[128];
4607  unsigned char dst_str[257];
4608  unsigned char iv_str[128];
4609  unsigned char add_str[128];
4610  unsigned char tag_str[128];
4611  unsigned char output[128];
4612  gcm_context ctx;
4613  unsigned int key_len;
4614  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
4615  int ret;
4616 
4617  memset(key_str, 0x00, 128);
4618  memset(src_str, 0x00, 128);
4619  memset(dst_str, 0x00, 257);
4620  memset(iv_str, 0x00, 128);
4621  memset(add_str, 0x00, 128);
4622  memset(tag_str, 0x00, 128);
4623  memset(output, 0x00, 128);
4624 
4625  key_len = unhexify( key_str, "c04200ce41ce77d772babb206315ec7d" );
4626  pt_len = unhexify( src_str, "" );
4627  iv_len = unhexify( iv_str, "a885d58f0f38f9ff26d906fa1bfb12f4" );
4628  add_len = unhexify( add_str, "" );
4629  unhexify( tag_str, "9ee0d025421f2bf18caf563953fb" );
4630 
4631  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4632  if( 0 == 0 )
4633  {
4634  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4635 
4636  if( strcmp( "FAIL", "" ) == 0 )
4637  {
4638  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4639  }
4640  else
4641  {
4642  hexify( dst_str, output, pt_len );
4643 
4644  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4645  }
4646  }
4647  }
4648  FCT_TEST_END();
4649 
4650 
4651  FCT_TEST_BGN(gcm_nist_validation_aes_12812800112_2)
4652  {
4653  unsigned char key_str[128];
4654  unsigned char src_str[128];
4655  unsigned char dst_str[257];
4656  unsigned char iv_str[128];
4657  unsigned char add_str[128];
4658  unsigned char tag_str[128];
4659  unsigned char output[128];
4660  gcm_context ctx;
4661  unsigned int key_len;
4662  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
4663  int ret;
4664 
4665  memset(key_str, 0x00, 128);
4666  memset(src_str, 0x00, 128);
4667  memset(dst_str, 0x00, 257);
4668  memset(iv_str, 0x00, 128);
4669  memset(add_str, 0x00, 128);
4670  memset(tag_str, 0x00, 128);
4671  memset(output, 0x00, 128);
4672 
4673  key_len = unhexify( key_str, "650df049461be341c3099bd1613dcead" );
4674  pt_len = unhexify( src_str, "" );
4675  iv_len = unhexify( iv_str, "8a4ff6327b49d297248ce2d5bd38afa8" );
4676  add_len = unhexify( add_str, "" );
4677  unhexify( tag_str, "13f067ef0d7b448d56e70d282fed" );
4678 
4679  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4680  if( 0 == 0 )
4681  {
4682  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4683 
4684  if( strcmp( "FAIL", "FAIL" ) == 0 )
4685  {
4686  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4687  }
4688  else
4689  {
4690  hexify( dst_str, output, pt_len );
4691 
4692  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4693  }
4694  }
4695  }
4696  FCT_TEST_END();
4697 
4698 
4699  FCT_TEST_BGN(gcm_nist_validation_aes_12812800104_0)
4700  {
4701  unsigned char key_str[128];
4702  unsigned char src_str[128];
4703  unsigned char dst_str[257];
4704  unsigned char iv_str[128];
4705  unsigned char add_str[128];
4706  unsigned char tag_str[128];
4707  unsigned char output[128];
4708  gcm_context ctx;
4709  unsigned int key_len;
4710  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
4711  int ret;
4712 
4713  memset(key_str, 0x00, 128);
4714  memset(src_str, 0x00, 128);
4715  memset(dst_str, 0x00, 257);
4716  memset(iv_str, 0x00, 128);
4717  memset(add_str, 0x00, 128);
4718  memset(tag_str, 0x00, 128);
4719  memset(output, 0x00, 128);
4720 
4721  key_len = unhexify( key_str, "ee61b5bf5060fcc637dc833926898508" );
4722  pt_len = unhexify( src_str, "" );
4723  iv_len = unhexify( iv_str, "b2dcf21f9ffa4a883044d29f087f9b85" );
4724  add_len = unhexify( add_str, "" );
4725  unhexify( tag_str, "9ab1d66666d4dea3cbb5982238" );
4726 
4727  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4728  if( 0 == 0 )
4729  {
4730  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4731 
4732  if( strcmp( "FAIL", "" ) == 0 )
4733  {
4734  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4735  }
4736  else
4737  {
4738  hexify( dst_str, output, pt_len );
4739 
4740  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4741  }
4742  }
4743  }
4744  FCT_TEST_END();
4745 
4746 
4747  FCT_TEST_BGN(gcm_nist_validation_aes_12812800104_1)
4748  {
4749  unsigned char key_str[128];
4750  unsigned char src_str[128];
4751  unsigned char dst_str[257];
4752  unsigned char iv_str[128];
4753  unsigned char add_str[128];
4754  unsigned char tag_str[128];
4755  unsigned char output[128];
4756  gcm_context ctx;
4757  unsigned int key_len;
4758  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
4759  int ret;
4760 
4761  memset(key_str, 0x00, 128);
4762  memset(src_str, 0x00, 128);
4763  memset(dst_str, 0x00, 257);
4764  memset(iv_str, 0x00, 128);
4765  memset(add_str, 0x00, 128);
4766  memset(tag_str, 0x00, 128);
4767  memset(output, 0x00, 128);
4768 
4769  key_len = unhexify( key_str, "01cc56ca7e64db7fbef66236a5c49493" );
4770  pt_len = unhexify( src_str, "" );
4771  iv_len = unhexify( iv_str, "8ea5b63004189792cc040ef18b37e550" );
4772  add_len = unhexify( add_str, "" );
4773  unhexify( tag_str, "d685aeb54aa129a21bed17766e" );
4774 
4775  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4776  if( 0 == 0 )
4777  {
4778  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4779 
4780  if( strcmp( "FAIL", "FAIL" ) == 0 )
4781  {
4782  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4783  }
4784  else
4785  {
4786  hexify( dst_str, output, pt_len );
4787 
4788  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4789  }
4790  }
4791  }
4792  FCT_TEST_END();
4793 
4794 
4795  FCT_TEST_BGN(gcm_nist_validation_aes_12812800104_2)
4796  {
4797  unsigned char key_str[128];
4798  unsigned char src_str[128];
4799  unsigned char dst_str[257];
4800  unsigned char iv_str[128];
4801  unsigned char add_str[128];
4802  unsigned char tag_str[128];
4803  unsigned char output[128];
4804  gcm_context ctx;
4805  unsigned int key_len;
4806  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
4807  int ret;
4808 
4809  memset(key_str, 0x00, 128);
4810  memset(src_str, 0x00, 128);
4811  memset(dst_str, 0x00, 257);
4812  memset(iv_str, 0x00, 128);
4813  memset(add_str, 0x00, 128);
4814  memset(tag_str, 0x00, 128);
4815  memset(output, 0x00, 128);
4816 
4817  key_len = unhexify( key_str, "134dd72ac8e28ab46720c2f42284a303" );
4818  pt_len = unhexify( src_str, "" );
4819  iv_len = unhexify( iv_str, "c6368e4c0ba0ec90fa7488af9997a4c7" );
4820  add_len = unhexify( add_str, "" );
4821  unhexify( tag_str, "4ad9cdf19ff7d7fd7e273efced" );
4822 
4823  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4824  if( 0 == 0 )
4825  {
4826  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4827 
4828  if( strcmp( "FAIL", "" ) == 0 )
4829  {
4830  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4831  }
4832  else
4833  {
4834  hexify( dst_str, output, pt_len );
4835 
4836  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4837  }
4838  }
4839  }
4840  FCT_TEST_END();
4841 
4842 
4843  FCT_TEST_BGN(gcm_nist_validation_aes_1281280096_0)
4844  {
4845  unsigned char key_str[128];
4846  unsigned char src_str[128];
4847  unsigned char dst_str[257];
4848  unsigned char iv_str[128];
4849  unsigned char add_str[128];
4850  unsigned char tag_str[128];
4851  unsigned char output[128];
4852  gcm_context ctx;
4853  unsigned int key_len;
4854  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
4855  int ret;
4856 
4857  memset(key_str, 0x00, 128);
4858  memset(src_str, 0x00, 128);
4859  memset(dst_str, 0x00, 257);
4860  memset(iv_str, 0x00, 128);
4861  memset(add_str, 0x00, 128);
4862  memset(tag_str, 0x00, 128);
4863  memset(output, 0x00, 128);
4864 
4865  key_len = unhexify( key_str, "180c04b2bde6901edcda66085f73ecd9" );
4866  pt_len = unhexify( src_str, "" );
4867  iv_len = unhexify( iv_str, "9193b206beade4cb036f01a9db187cb8" );
4868  add_len = unhexify( add_str, "" );
4869  unhexify( tag_str, "530f5e9ed0879ccef3a7b360" );
4870 
4871  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4872  if( 0 == 0 )
4873  {
4874  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4875 
4876  if( strcmp( "FAIL", "" ) == 0 )
4877  {
4878  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4879  }
4880  else
4881  {
4882  hexify( dst_str, output, pt_len );
4883 
4884  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
4885  }
4886  }
4887  }
4888  FCT_TEST_END();
4889 
4890 
4891  FCT_TEST_BGN(gcm_nist_validation_aes_1281280096_1)
4892  {
4893  unsigned char key_str[128];
4894  unsigned char src_str[128];
4895  unsigned char dst_str[257];
4896  unsigned char iv_str[128];
4897  unsigned char add_str[128];
4898  unsigned char tag_str[128];
4899  unsigned char output[128];
4900  gcm_context ctx;
4901  unsigned int key_len;
4902  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
4903  int ret;
4904 
4905  memset(key_str, 0x00, 128);
4906  memset(src_str, 0x00, 128);
4907  memset(dst_str, 0x00, 257);
4908  memset(iv_str, 0x00, 128);
4909  memset(add_str, 0x00, 128);
4910  memset(tag_str, 0x00, 128);
4911  memset(output, 0x00, 128);
4912 
4913  key_len = unhexify( key_str, "aaac85742a55ffa07e98106d6d6b1004" );
4914  pt_len = unhexify( src_str, "" );
4915  iv_len = unhexify( iv_str, "630cd8ab849253c4da95ac80324ecc28" );
4916  add_len = unhexify( add_str, "" );
4917  unhexify( tag_str, "37911820c810e3700c3a9321" );
4918 
4919  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4920  if( 0 == 0 )
4921  {
4922  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4923 
4924  if( strcmp( "FAIL", "FAIL" ) == 0 )
4925  {
4926  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4927  }
4928  else
4929  {
4930  hexify( dst_str, output, pt_len );
4931 
4932  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4933  }
4934  }
4935  }
4936  FCT_TEST_END();
4937 
4938 
4939  FCT_TEST_BGN(gcm_nist_validation_aes_1281280096_2)
4940  {
4941  unsigned char key_str[128];
4942  unsigned char src_str[128];
4943  unsigned char dst_str[257];
4944  unsigned char iv_str[128];
4945  unsigned char add_str[128];
4946  unsigned char tag_str[128];
4947  unsigned char output[128];
4948  gcm_context ctx;
4949  unsigned int key_len;
4950  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
4951  int ret;
4952 
4953  memset(key_str, 0x00, 128);
4954  memset(src_str, 0x00, 128);
4955  memset(dst_str, 0x00, 257);
4956  memset(iv_str, 0x00, 128);
4957  memset(add_str, 0x00, 128);
4958  memset(tag_str, 0x00, 128);
4959  memset(output, 0x00, 128);
4960 
4961  key_len = unhexify( key_str, "ab663c4f8f2fdc7d5eabf6ef26169b4e" );
4962  pt_len = unhexify( src_str, "" );
4963  iv_len = unhexify( iv_str, "86e6100669929e329a1d258cd3552dc9" );
4964  add_len = unhexify( add_str, "" );
4965  unhexify( tag_str, "958d6141f7fb2b2dc7d851a6" );
4966 
4967  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
4968  if( 0 == 0 )
4969  {
4970  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
4971 
4972  if( strcmp( "FAIL", "FAIL" ) == 0 )
4973  {
4974  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
4975  }
4976  else
4977  {
4978  hexify( dst_str, output, pt_len );
4979 
4980  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
4981  }
4982  }
4983  }
4984  FCT_TEST_END();
4985 
4986 
4987  FCT_TEST_BGN(gcm_nist_validation_aes_1281280064_0)
4988  {
4989  unsigned char key_str[128];
4990  unsigned char src_str[128];
4991  unsigned char dst_str[257];
4992  unsigned char iv_str[128];
4993  unsigned char add_str[128];
4994  unsigned char tag_str[128];
4995  unsigned char output[128];
4996  gcm_context ctx;
4997  unsigned int key_len;
4998  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
4999  int ret;
5000 
5001  memset(key_str, 0x00, 128);
5002  memset(src_str, 0x00, 128);
5003  memset(dst_str, 0x00, 257);
5004  memset(iv_str, 0x00, 128);
5005  memset(add_str, 0x00, 128);
5006  memset(tag_str, 0x00, 128);
5007  memset(output, 0x00, 128);
5008 
5009  key_len = unhexify( key_str, "0dd756d49fd25380c4026ea03cafc2da" );
5010  pt_len = unhexify( src_str, "" );
5011  iv_len = unhexify( iv_str, "6a6f7e39b0d730ea1670e13d16c12c28" );
5012  add_len = unhexify( add_str, "" );
5013  unhexify( tag_str, "872ef05a28da5ea1" );
5014 
5015  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5016  if( 0 == 0 )
5017  {
5018  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5019 
5020  if( strcmp( "FAIL", "" ) == 0 )
5021  {
5022  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5023  }
5024  else
5025  {
5026  hexify( dst_str, output, pt_len );
5027 
5028  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5029  }
5030  }
5031  }
5032  FCT_TEST_END();
5033 
5034 
5035  FCT_TEST_BGN(gcm_nist_validation_aes_1281280064_1)
5036  {
5037  unsigned char key_str[128];
5038  unsigned char src_str[128];
5039  unsigned char dst_str[257];
5040  unsigned char iv_str[128];
5041  unsigned char add_str[128];
5042  unsigned char tag_str[128];
5043  unsigned char output[128];
5044  gcm_context ctx;
5045  unsigned int key_len;
5046  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
5047  int ret;
5048 
5049  memset(key_str, 0x00, 128);
5050  memset(src_str, 0x00, 128);
5051  memset(dst_str, 0x00, 257);
5052  memset(iv_str, 0x00, 128);
5053  memset(add_str, 0x00, 128);
5054  memset(tag_str, 0x00, 128);
5055  memset(output, 0x00, 128);
5056 
5057  key_len = unhexify( key_str, "bd8a834b288bdc7578b6c6ab36f5d068" );
5058  pt_len = unhexify( src_str, "" );
5059  iv_len = unhexify( iv_str, "aa77de0af5fa4dd1ed2ada5cb94813a0" );
5060  add_len = unhexify( add_str, "" );
5061  unhexify( tag_str, "c5c094e83755f2b6" );
5062 
5063  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5064  if( 0 == 0 )
5065  {
5066  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5067 
5068  if( strcmp( "FAIL", "" ) == 0 )
5069  {
5070  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5071  }
5072  else
5073  {
5074  hexify( dst_str, output, pt_len );
5075 
5076  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5077  }
5078  }
5079  }
5080  FCT_TEST_END();
5081 
5082 
5083  FCT_TEST_BGN(gcm_nist_validation_aes_1281280064_2)
5084  {
5085  unsigned char key_str[128];
5086  unsigned char src_str[128];
5087  unsigned char dst_str[257];
5088  unsigned char iv_str[128];
5089  unsigned char add_str[128];
5090  unsigned char tag_str[128];
5091  unsigned char output[128];
5092  gcm_context ctx;
5093  unsigned int key_len;
5094  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
5095  int ret;
5096 
5097  memset(key_str, 0x00, 128);
5098  memset(src_str, 0x00, 128);
5099  memset(dst_str, 0x00, 257);
5100  memset(iv_str, 0x00, 128);
5101  memset(add_str, 0x00, 128);
5102  memset(tag_str, 0x00, 128);
5103  memset(output, 0x00, 128);
5104 
5105  key_len = unhexify( key_str, "020d280dbd06939bbb5e6edc6f6d39c6" );
5106  pt_len = unhexify( src_str, "" );
5107  iv_len = unhexify( iv_str, "09aea6f0e57598452719d6f63b6fe5a0" );
5108  add_len = unhexify( add_str, "" );
5109  unhexify( tag_str, "05d6c56ba601e85b" );
5110 
5111  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5112  if( 0 == 0 )
5113  {
5114  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5115 
5116  if( strcmp( "FAIL", "FAIL" ) == 0 )
5117  {
5118  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5119  }
5120  else
5121  {
5122  hexify( dst_str, output, pt_len );
5123 
5124  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
5125  }
5126  }
5127  }
5128  FCT_TEST_END();
5129 
5130 
5131  FCT_TEST_BGN(gcm_nist_validation_aes_1281280032_0)
5132  {
5133  unsigned char key_str[128];
5134  unsigned char src_str[128];
5135  unsigned char dst_str[257];
5136  unsigned char iv_str[128];
5137  unsigned char add_str[128];
5138  unsigned char tag_str[128];
5139  unsigned char output[128];
5140  gcm_context ctx;
5141  unsigned int key_len;
5142  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
5143  int ret;
5144 
5145  memset(key_str, 0x00, 128);
5146  memset(src_str, 0x00, 128);
5147  memset(dst_str, 0x00, 257);
5148  memset(iv_str, 0x00, 128);
5149  memset(add_str, 0x00, 128);
5150  memset(tag_str, 0x00, 128);
5151  memset(output, 0x00, 128);
5152 
5153  key_len = unhexify( key_str, "e47f41a27a2722df293c1431badc0f90" );
5154  pt_len = unhexify( src_str, "" );
5155  iv_len = unhexify( iv_str, "227c036fca03171a890806b9fa0c250d" );
5156  add_len = unhexify( add_str, "" );
5157  unhexify( tag_str, "86c22189" );
5158 
5159  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5160  if( 0 == 0 )
5161  {
5162  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5163 
5164  if( strcmp( "FAIL", "FAIL" ) == 0 )
5165  {
5166  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5167  }
5168  else
5169  {
5170  hexify( dst_str, output, pt_len );
5171 
5172  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
5173  }
5174  }
5175  }
5176  FCT_TEST_END();
5177 
5178 
5179  FCT_TEST_BGN(gcm_nist_validation_aes_1281280032_1)
5180  {
5181  unsigned char key_str[128];
5182  unsigned char src_str[128];
5183  unsigned char dst_str[257];
5184  unsigned char iv_str[128];
5185  unsigned char add_str[128];
5186  unsigned char tag_str[128];
5187  unsigned char output[128];
5188  gcm_context ctx;
5189  unsigned int key_len;
5190  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
5191  int ret;
5192 
5193  memset(key_str, 0x00, 128);
5194  memset(src_str, 0x00, 128);
5195  memset(dst_str, 0x00, 257);
5196  memset(iv_str, 0x00, 128);
5197  memset(add_str, 0x00, 128);
5198  memset(tag_str, 0x00, 128);
5199  memset(output, 0x00, 128);
5200 
5201  key_len = unhexify( key_str, "9d3e112114b94e26e93d3855d4be26bd" );
5202  pt_len = unhexify( src_str, "" );
5203  iv_len = unhexify( iv_str, "99b98525160c4bb2029da5553ff82b59" );
5204  add_len = unhexify( add_str, "" );
5205  unhexify( tag_str, "33bee715" );
5206 
5207  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5208  if( 0 == 0 )
5209  {
5210  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5211 
5212  if( strcmp( "FAIL", "FAIL" ) == 0 )
5213  {
5214  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5215  }
5216  else
5217  {
5218  hexify( dst_str, output, pt_len );
5219 
5220  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
5221  }
5222  }
5223  }
5224  FCT_TEST_END();
5225 
5226 
5227  FCT_TEST_BGN(gcm_nist_validation_aes_1281280032_2)
5228  {
5229  unsigned char key_str[128];
5230  unsigned char src_str[128];
5231  unsigned char dst_str[257];
5232  unsigned char iv_str[128];
5233  unsigned char add_str[128];
5234  unsigned char tag_str[128];
5235  unsigned char output[128];
5236  gcm_context ctx;
5237  unsigned int key_len;
5238  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
5239  int ret;
5240 
5241  memset(key_str, 0x00, 128);
5242  memset(src_str, 0x00, 128);
5243  memset(dst_str, 0x00, 257);
5244  memset(iv_str, 0x00, 128);
5245  memset(add_str, 0x00, 128);
5246  memset(tag_str, 0x00, 128);
5247  memset(output, 0x00, 128);
5248 
5249  key_len = unhexify( key_str, "5b4b7688588125349fbb66004a30d5d4" );
5250  pt_len = unhexify( src_str, "" );
5251  iv_len = unhexify( iv_str, "b4ae363edb529d8b927c051cf21a2d9d" );
5252  add_len = unhexify( add_str, "" );
5253  unhexify( tag_str, "6a920617" );
5254 
5255  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5256  if( 0 == 0 )
5257  {
5258  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5259 
5260  if( strcmp( "FAIL", "" ) == 0 )
5261  {
5262  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5263  }
5264  else
5265  {
5266  hexify( dst_str, output, pt_len );
5267 
5268  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5269  }
5270  }
5271  }
5272  FCT_TEST_END();
5273 
5274 
5275  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024128_0)
5276  {
5277  unsigned char key_str[128];
5278  unsigned char src_str[128];
5279  unsigned char dst_str[257];
5280  unsigned char iv_str[128];
5281  unsigned char add_str[128];
5282  unsigned char tag_str[128];
5283  unsigned char output[128];
5284  gcm_context ctx;
5285  unsigned int key_len;
5286  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
5287  int ret;
5288 
5289  memset(key_str, 0x00, 128);
5290  memset(src_str, 0x00, 128);
5291  memset(dst_str, 0x00, 257);
5292  memset(iv_str, 0x00, 128);
5293  memset(add_str, 0x00, 128);
5294  memset(tag_str, 0x00, 128);
5295  memset(output, 0x00, 128);
5296 
5297  key_len = unhexify( key_str, "c4b6c5b8e21c32f36b0ae4ef3b75d5cd" );
5298  pt_len = unhexify( src_str, "" );
5299  iv_len = unhexify( iv_str, "3d1036bf0000e6f1b77a799f2ef32dec" );
5300  add_len = unhexify( add_str, "1cf2b6cbe86a87b4b5bb3cc50024aeb27c48143658d47b41f2f20b87ed67bd6fc3b85a3a803f66d3576608f5d6ce6cad11e02fe12de5390722dccb8242e1dd140051bef51aa9716c860d45d45bca6effbb1a4797e6e7406a04db5d823766c0f011ebc28e9a8cd4446ec8a75ea8bdc1b2fdbb5cc364fa9877886e30404593df34" );
5301  unhexify( tag_str, "a49725014c214ef7cc2d28b9b2b53da7" );
5302 
5303  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5304  if( 0 == 0 )
5305  {
5306  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5307 
5308  if( strcmp( "FAIL", "FAIL" ) == 0 )
5309  {
5310  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5311  }
5312  else
5313  {
5314  hexify( dst_str, output, pt_len );
5315 
5316  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
5317  }
5318  }
5319  }
5320  FCT_TEST_END();
5321 
5322 
5323  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024128_1)
5324  {
5325  unsigned char key_str[128];
5326  unsigned char src_str[128];
5327  unsigned char dst_str[257];
5328  unsigned char iv_str[128];
5329  unsigned char add_str[128];
5330  unsigned char tag_str[128];
5331  unsigned char output[128];
5332  gcm_context ctx;
5333  unsigned int key_len;
5334  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
5335  int ret;
5336 
5337  memset(key_str, 0x00, 128);
5338  memset(src_str, 0x00, 128);
5339  memset(dst_str, 0x00, 257);
5340  memset(iv_str, 0x00, 128);
5341  memset(add_str, 0x00, 128);
5342  memset(tag_str, 0x00, 128);
5343  memset(output, 0x00, 128);
5344 
5345  key_len = unhexify( key_str, "63c3f81500746eaf383fe3975d84f849" );
5346  pt_len = unhexify( src_str, "" );
5347  iv_len = unhexify( iv_str, "0799d4152fd73c1604b4610cf7171fe1" );
5348  add_len = unhexify( add_str, "cb8248e5f904cc9ccccf6f273fe621eee1b4d7ed98480f9e806a48b84e2d6a733772ecf8fb7fe91805715cddab2b462b89f6e6c7cf873f65031f13c357d5f57b00b7c391c39e78ad1ed94be236ca0ae316bce11bc33c5d701fdfc58abbe918b9c42f7b3d6e89d46f9784b388a6e6daf47730b9fa665d755a17e89932fa669c44" );
5349  unhexify( tag_str, "c53d01e53ee4a6ea106ea4a66538265e" );
5350 
5351  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5352  if( 0 == 0 )
5353  {
5354  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5355 
5356  if( strcmp( "FAIL", "" ) == 0 )
5357  {
5358  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5359  }
5360  else
5361  {
5362  hexify( dst_str, output, pt_len );
5363 
5364  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5365  }
5366  }
5367  }
5368  FCT_TEST_END();
5369 
5370 
5371  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024128_2)
5372  {
5373  unsigned char key_str[128];
5374  unsigned char src_str[128];
5375  unsigned char dst_str[257];
5376  unsigned char iv_str[128];
5377  unsigned char add_str[128];
5378  unsigned char tag_str[128];
5379  unsigned char output[128];
5380  gcm_context ctx;
5381  unsigned int key_len;
5382  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
5383  int ret;
5384 
5385  memset(key_str, 0x00, 128);
5386  memset(src_str, 0x00, 128);
5387  memset(dst_str, 0x00, 257);
5388  memset(iv_str, 0x00, 128);
5389  memset(add_str, 0x00, 128);
5390  memset(tag_str, 0x00, 128);
5391  memset(output, 0x00, 128);
5392 
5393  key_len = unhexify( key_str, "b0c88b191ce6e8e4a3941f7960b7eae5" );
5394  pt_len = unhexify( src_str, "" );
5395  iv_len = unhexify( iv_str, "e2a899961c332c815685c553351fa519" );
5396  add_len = unhexify( add_str, "308bf10570af48d632911f3641dea60d78046211c01a63bb8e4e5cbddfff8841d2f2b11e18ccb2170805ef4cacf7804d64e0feef40731a1704907f33b77788c18ccf35b224ec3046a67664ac9a3481d2385b6ddeec6da4f32423f94ea9663a5c51cc388cef33744a8159b4fb654dfdb5092718bf926c824be31197f07f276b5f" );
5397  unhexify( tag_str, "92604d37407aff33f8b677326cbb94fc" );
5398 
5399  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5400  if( 0 == 0 )
5401  {
5402  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5403 
5404  if( strcmp( "FAIL", "FAIL" ) == 0 )
5405  {
5406  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5407  }
5408  else
5409  {
5410  hexify( dst_str, output, pt_len );
5411 
5412  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
5413  }
5414  }
5415  }
5416  FCT_TEST_END();
5417 
5418 
5419  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024120_0)
5420  {
5421  unsigned char key_str[128];
5422  unsigned char src_str[128];
5423  unsigned char dst_str[257];
5424  unsigned char iv_str[128];
5425  unsigned char add_str[128];
5426  unsigned char tag_str[128];
5427  unsigned char output[128];
5428  gcm_context ctx;
5429  unsigned int key_len;
5430  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
5431  int ret;
5432 
5433  memset(key_str, 0x00, 128);
5434  memset(src_str, 0x00, 128);
5435  memset(dst_str, 0x00, 257);
5436  memset(iv_str, 0x00, 128);
5437  memset(add_str, 0x00, 128);
5438  memset(tag_str, 0x00, 128);
5439  memset(output, 0x00, 128);
5440 
5441  key_len = unhexify( key_str, "c818dfa0885a09f65ef78712f5ce6609" );
5442  pt_len = unhexify( src_str, "" );
5443  iv_len = unhexify( iv_str, "ca279284723530fdd68ae880e0ce775c" );
5444  add_len = unhexify( add_str, "2a562abdbb483ca5f355f9cc1c5e607bdd624a078a76b717ce0f8f35d0d4c54b629f372f15d20c848d01420c6af5a7040d42063704a17b46259dcc53723caf2d4bf556143ff9117c752fa4f22c9c155c99b7bf5949d089cdafd562165b9cbf53ff51cec21f49128c8a599718bbcdb4a5d705d20509c44c8945e2a133164b9942" );
5445  unhexify( tag_str, "20e9a3a98d71d460743e1efaab13c6" );
5446 
5447  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5448  if( 0 == 0 )
5449  {
5450  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5451 
5452  if( strcmp( "FAIL", "" ) == 0 )
5453  {
5454  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5455  }
5456  else
5457  {
5458  hexify( dst_str, output, pt_len );
5459 
5460  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5461  }
5462  }
5463  }
5464  FCT_TEST_END();
5465 
5466 
5467  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024120_1)
5468  {
5469  unsigned char key_str[128];
5470  unsigned char src_str[128];
5471  unsigned char dst_str[257];
5472  unsigned char iv_str[128];
5473  unsigned char add_str[128];
5474  unsigned char tag_str[128];
5475  unsigned char output[128];
5476  gcm_context ctx;
5477  unsigned int key_len;
5478  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
5479  int ret;
5480 
5481  memset(key_str, 0x00, 128);
5482  memset(src_str, 0x00, 128);
5483  memset(dst_str, 0x00, 257);
5484  memset(iv_str, 0x00, 128);
5485  memset(add_str, 0x00, 128);
5486  memset(tag_str, 0x00, 128);
5487  memset(output, 0x00, 128);
5488 
5489  key_len = unhexify( key_str, "2354c6b6afaa883e7ce91faca4981f8b" );
5490  pt_len = unhexify( src_str, "" );
5491  iv_len = unhexify( iv_str, "604f2730c756c8c39a0527093bc2feb5" );
5492  add_len = unhexify( add_str, "959b4b0b9ce2e9120b327d2d090117553999ee10bdd384a546fc6de0957ef4b447daf07b3d07ef7dbc811f36b0fc09a175d26e4d1263cb5e21eda5ecab85d763807bb20b3cb6ac3f31d548dff00aae058d434ebcf6f7e3a37f11324134f453dd0ea7f51094863486426ff1706129a5a93c53d8c5ccb56cafa5881981fe233cb0" );
5493  unhexify( tag_str, "3588c9aa769897dfa328549fbbd10a" );
5494 
5495  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5496  if( 0 == 0 )
5497  {
5498  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5499 
5500  if( strcmp( "FAIL", "" ) == 0 )
5501  {
5502  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5503  }
5504  else
5505  {
5506  hexify( dst_str, output, pt_len );
5507 
5508  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5509  }
5510  }
5511  }
5512  FCT_TEST_END();
5513 
5514 
5515  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024120_2)
5516  {
5517  unsigned char key_str[128];
5518  unsigned char src_str[128];
5519  unsigned char dst_str[257];
5520  unsigned char iv_str[128];
5521  unsigned char add_str[128];
5522  unsigned char tag_str[128];
5523  unsigned char output[128];
5524  gcm_context ctx;
5525  unsigned int key_len;
5526  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
5527  int ret;
5528 
5529  memset(key_str, 0x00, 128);
5530  memset(src_str, 0x00, 128);
5531  memset(dst_str, 0x00, 257);
5532  memset(iv_str, 0x00, 128);
5533  memset(add_str, 0x00, 128);
5534  memset(tag_str, 0x00, 128);
5535  memset(output, 0x00, 128);
5536 
5537  key_len = unhexify( key_str, "b0af48e6aebbb6ff5b7c92bd140b085f" );
5538  pt_len = unhexify( src_str, "" );
5539  iv_len = unhexify( iv_str, "d210d6502a5221ac1274a9c7f5a81725" );
5540  add_len = unhexify( add_str, "d725311ca10eb4b4aa24e6dd19c5e72dc34fc1ff53feb25d924a9b7d8d72205790ca4b1275bd93ad60c27a5587a45659bca07c111e9748fb683a03465153ffd735b7d134b479674ab8596f0596496fe2090f623fd1e4dd730c5283d8b172db8a25df42d9b34f388ed32676a56b8ba03347e47379702654508ccd0a21ff03516e" );
5541  unhexify( tag_str, "e6222f068a1e18f09ba6c771eabd86" );
5542 
5543  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5544  if( 0 == 0 )
5545  {
5546  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5547 
5548  if( strcmp( "FAIL", "FAIL" ) == 0 )
5549  {
5550  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5551  }
5552  else
5553  {
5554  hexify( dst_str, output, pt_len );
5555 
5556  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
5557  }
5558  }
5559  }
5560  FCT_TEST_END();
5561 
5562 
5563  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024112_0)
5564  {
5565  unsigned char key_str[128];
5566  unsigned char src_str[128];
5567  unsigned char dst_str[257];
5568  unsigned char iv_str[128];
5569  unsigned char add_str[128];
5570  unsigned char tag_str[128];
5571  unsigned char output[128];
5572  gcm_context ctx;
5573  unsigned int key_len;
5574  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
5575  int ret;
5576 
5577  memset(key_str, 0x00, 128);
5578  memset(src_str, 0x00, 128);
5579  memset(dst_str, 0x00, 257);
5580  memset(iv_str, 0x00, 128);
5581  memset(add_str, 0x00, 128);
5582  memset(tag_str, 0x00, 128);
5583  memset(output, 0x00, 128);
5584 
5585  key_len = unhexify( key_str, "a05fe482fe164b2eca7f6c3e377b39d8" );
5586  pt_len = unhexify( src_str, "" );
5587  iv_len = unhexify( iv_str, "145327bcc10335fccb93afbf4b17e6e7" );
5588  add_len = unhexify( add_str, "ea6f2e93b5e1bf127d40440b8d6397405246b1b48eebe16964f18928f6b4b8ee2c36322d7126905c1a5b816996e340404b586edc2d77afac11a6c1266511f9eff1a320b035442d4078f8e42ca63cf26d12a971a7adf4645d1bd9a8e4d0a20722f7c2d529beaecc4033f7738075e1cdc6d8a929da5582540678935b82e7b7ba68" );
5589  unhexify( tag_str, "3900bde9fa9ae2cbeee54d04f224" );
5590 
5591  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5592  if( 0 == 0 )
5593  {
5594  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5595 
5596  if( strcmp( "FAIL", "" ) == 0 )
5597  {
5598  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5599  }
5600  else
5601  {
5602  hexify( dst_str, output, pt_len );
5603 
5604  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5605  }
5606  }
5607  }
5608  FCT_TEST_END();
5609 
5610 
5611  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024112_1)
5612  {
5613  unsigned char key_str[128];
5614  unsigned char src_str[128];
5615  unsigned char dst_str[257];
5616  unsigned char iv_str[128];
5617  unsigned char add_str[128];
5618  unsigned char tag_str[128];
5619  unsigned char output[128];
5620  gcm_context ctx;
5621  unsigned int key_len;
5622  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
5623  int ret;
5624 
5625  memset(key_str, 0x00, 128);
5626  memset(src_str, 0x00, 128);
5627  memset(dst_str, 0x00, 257);
5628  memset(iv_str, 0x00, 128);
5629  memset(add_str, 0x00, 128);
5630  memset(tag_str, 0x00, 128);
5631  memset(output, 0x00, 128);
5632 
5633  key_len = unhexify( key_str, "dacbadf819eb16a63f6f091d13ed04d4" );
5634  pt_len = unhexify( src_str, "" );
5635  iv_len = unhexify( iv_str, "b9ebce724b0dcb0989ac2d8e7ff8aaec" );
5636  add_len = unhexify( add_str, "7dc6e2189d8a96f3507e352e05e8fd1b4bab988c2f1c706115887119f63b78084f015d85f6b460901a02880103e4d36e8f6527dfd74e4a3acd3f578c0cc726b528875f701ff8b66e5c11b4689c346a098e123bebfa253362cb86829be73c2b85a6881fa976aa730fabb76775027feec7fd920a6c8965a4a509ea812d7c413a95" );
5637  unhexify( tag_str, "8988fca83c8cfb1f8feefac46f04" );
5638 
5639  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5640  if( 0 == 0 )
5641  {
5642  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5643 
5644  if( strcmp( "FAIL", "FAIL" ) == 0 )
5645  {
5646  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5647  }
5648  else
5649  {
5650  hexify( dst_str, output, pt_len );
5651 
5652  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
5653  }
5654  }
5655  }
5656  FCT_TEST_END();
5657 
5658 
5659  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024112_2)
5660  {
5661  unsigned char key_str[128];
5662  unsigned char src_str[128];
5663  unsigned char dst_str[257];
5664  unsigned char iv_str[128];
5665  unsigned char add_str[128];
5666  unsigned char tag_str[128];
5667  unsigned char output[128];
5668  gcm_context ctx;
5669  unsigned int key_len;
5670  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
5671  int ret;
5672 
5673  memset(key_str, 0x00, 128);
5674  memset(src_str, 0x00, 128);
5675  memset(dst_str, 0x00, 257);
5676  memset(iv_str, 0x00, 128);
5677  memset(add_str, 0x00, 128);
5678  memset(tag_str, 0x00, 128);
5679  memset(output, 0x00, 128);
5680 
5681  key_len = unhexify( key_str, "969244c7444f3f3bf193b28f8e8e96dc" );
5682  pt_len = unhexify( src_str, "" );
5683  iv_len = unhexify( iv_str, "49b2845a1a1c87fa66eb8f78c05ac029" );
5684  add_len = unhexify( add_str, "1414a07e86d8b61d1eff43e1ff4ab42c1c95e159058b74c731e3007d21a5eb78bc17b7e920363a3974aeb8608813dc9a4655199b6703ed337450702d8ab16a89776831b2c7c811fec3acc23598a0aa01680a7bf42a4e258145beb08c9f0eacf2bb5f56d26bea3ad11e1a956a630b80f3d22bf35592b4704f7c464b08b06dd7f8" );
5685  unhexify( tag_str, "a291c7527385f037f62e60fd8a96" );
5686 
5687  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5688  if( 0 == 0 )
5689  {
5690  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5691 
5692  if( strcmp( "FAIL", "" ) == 0 )
5693  {
5694  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5695  }
5696  else
5697  {
5698  hexify( dst_str, output, pt_len );
5699 
5700  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5701  }
5702  }
5703  }
5704  FCT_TEST_END();
5705 
5706 
5707  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024104_0)
5708  {
5709  unsigned char key_str[128];
5710  unsigned char src_str[128];
5711  unsigned char dst_str[257];
5712  unsigned char iv_str[128];
5713  unsigned char add_str[128];
5714  unsigned char tag_str[128];
5715  unsigned char output[128];
5716  gcm_context ctx;
5717  unsigned int key_len;
5718  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
5719  int ret;
5720 
5721  memset(key_str, 0x00, 128);
5722  memset(src_str, 0x00, 128);
5723  memset(dst_str, 0x00, 257);
5724  memset(iv_str, 0x00, 128);
5725  memset(add_str, 0x00, 128);
5726  memset(tag_str, 0x00, 128);
5727  memset(output, 0x00, 128);
5728 
5729  key_len = unhexify( key_str, "525abe490c8434802b69439c590a5290" );
5730  pt_len = unhexify( src_str, "" );
5731  iv_len = unhexify( iv_str, "141f79f0501316e66451c41c7af0f0cd" );
5732  add_len = unhexify( add_str, "be440db66d3f81be467605a7b2805ec1df5e71e1b1b04bd7a4d05e912f5aa1912ba08de72df18613b32b7edf78963c48c80c25178b3b19262b85bb829f5377e0b368b500d6d3b442f54172d4ca4500eb5b4d478b602e5dc11d090539455087ce1e5b9ea74355fc06e9b60cbf25a9804d3f8c623fff130abc48bc2d8d116b8366" );
5733  unhexify( tag_str, "038c7e95f790e6ca5ce73f9551" );
5734 
5735  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5736  if( 0 == 0 )
5737  {
5738  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5739 
5740  if( strcmp( "FAIL", "" ) == 0 )
5741  {
5742  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5743  }
5744  else
5745  {
5746  hexify( dst_str, output, pt_len );
5747 
5748  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5749  }
5750  }
5751  }
5752  FCT_TEST_END();
5753 
5754 
5755  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024104_1)
5756  {
5757  unsigned char key_str[128];
5758  unsigned char src_str[128];
5759  unsigned char dst_str[257];
5760  unsigned char iv_str[128];
5761  unsigned char add_str[128];
5762  unsigned char tag_str[128];
5763  unsigned char output[128];
5764  gcm_context ctx;
5765  unsigned int key_len;
5766  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
5767  int ret;
5768 
5769  memset(key_str, 0x00, 128);
5770  memset(src_str, 0x00, 128);
5771  memset(dst_str, 0x00, 257);
5772  memset(iv_str, 0x00, 128);
5773  memset(add_str, 0x00, 128);
5774  memset(tag_str, 0x00, 128);
5775  memset(output, 0x00, 128);
5776 
5777  key_len = unhexify( key_str, "51644e025659de983f5c8156516b812e" );
5778  pt_len = unhexify( src_str, "" );
5779  iv_len = unhexify( iv_str, "614837c743d0974e9cca497f13038c02" );
5780  add_len = unhexify( add_str, "60c5d062ade2c5c2dec68b734dd3e58ec474a586d1c4797fdfa2337800510134cb27a10d501927632af3c1febc275010c0d2e5abee630cd2bc792963fa82a42286ab047b934a261927311b40f5f953bfd661427921147cac7613d95ee86e16326ef67c1ed097e8fb87a78753d785de34e03a182232786079cb6be00182e41c9e" );
5781  unhexify( tag_str, "77e3deba2c7f9386f85bc4a801" );
5782 
5783  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5784  if( 0 == 0 )
5785  {
5786  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5787 
5788  if( strcmp( "FAIL", "" ) == 0 )
5789  {
5790  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5791  }
5792  else
5793  {
5794  hexify( dst_str, output, pt_len );
5795 
5796  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5797  }
5798  }
5799  }
5800  FCT_TEST_END();
5801 
5802 
5803  FCT_TEST_BGN(gcm_nist_validation_aes_12812801024104_2)
5804  {
5805  unsigned char key_str[128];
5806  unsigned char src_str[128];
5807  unsigned char dst_str[257];
5808  unsigned char iv_str[128];
5809  unsigned char add_str[128];
5810  unsigned char tag_str[128];
5811  unsigned char output[128];
5812  gcm_context ctx;
5813  unsigned int key_len;
5814  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
5815  int ret;
5816 
5817  memset(key_str, 0x00, 128);
5818  memset(src_str, 0x00, 128);
5819  memset(dst_str, 0x00, 257);
5820  memset(iv_str, 0x00, 128);
5821  memset(add_str, 0x00, 128);
5822  memset(tag_str, 0x00, 128);
5823  memset(output, 0x00, 128);
5824 
5825  key_len = unhexify( key_str, "08566ca7310302dfb84d76ea0525ba20" );
5826  pt_len = unhexify( src_str, "" );
5827  iv_len = unhexify( iv_str, "5f20ec9c35c08aa7f1c0e8a20fdbd2b3" );
5828  add_len = unhexify( add_str, "5d84e32768b8d1e7e3c426b3118d48e35491bf1bb454b359c8429220216efd8826be94fe1919409a128ccd8125a594f1691c9421fc3dbbb3f757bf2355bb0d074ceec165eb70e26eb53fa2cb5d84dfae06babb557805ef7b8c61c1bc76137571bcc5e84bf5987dc49013831d78bd497ccc49cde7dca2cb75e7ab967da8c6ce81" );
5829  unhexify( tag_str, "873f037fc05252a44dc76f8155" );
5830 
5831  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5832  if( 0 == 0 )
5833  {
5834  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5835 
5836  if( strcmp( "FAIL", "" ) == 0 )
5837  {
5838  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5839  }
5840  else
5841  {
5842  hexify( dst_str, output, pt_len );
5843 
5844  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5845  }
5846  }
5847  }
5848  FCT_TEST_END();
5849 
5850 
5851  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102496_0)
5852  {
5853  unsigned char key_str[128];
5854  unsigned char src_str[128];
5855  unsigned char dst_str[257];
5856  unsigned char iv_str[128];
5857  unsigned char add_str[128];
5858  unsigned char tag_str[128];
5859  unsigned char output[128];
5860  gcm_context ctx;
5861  unsigned int key_len;
5862  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
5863  int ret;
5864 
5865  memset(key_str, 0x00, 128);
5866  memset(src_str, 0x00, 128);
5867  memset(dst_str, 0x00, 257);
5868  memset(iv_str, 0x00, 128);
5869  memset(add_str, 0x00, 128);
5870  memset(tag_str, 0x00, 128);
5871  memset(output, 0x00, 128);
5872 
5873  key_len = unhexify( key_str, "dfb54db96383fa911bf5b4fa1218ef9a" );
5874  pt_len = unhexify( src_str, "" );
5875  iv_len = unhexify( iv_str, "7e849e24983f63f1194b396bbd2d55e0" );
5876  add_len = unhexify( add_str, "d3fb689c5818810dd104693f3306a10b27178444af26798a194f7c2ab31ff3a172904b951942b1a26c8ae5b5b1ee2d86dc78bb72a335fde350766d7d9aef6f549871dd46b04b2cc319fcdd47be437d431ad18cab82d51ca9fa57f4108a8de622a92f87d28c0349fab27757fd773413f559a8c00d30e258c1f6cd96f9759bd957" );
5877  unhexify( tag_str, "dada7fc7fed58db462854ef6" );
5878 
5879  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5880  if( 0 == 0 )
5881  {
5882  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5883 
5884  if( strcmp( "FAIL", "FAIL" ) == 0 )
5885  {
5886  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5887  }
5888  else
5889  {
5890  hexify( dst_str, output, pt_len );
5891 
5892  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
5893  }
5894  }
5895  }
5896  FCT_TEST_END();
5897 
5898 
5899  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102496_1)
5900  {
5901  unsigned char key_str[128];
5902  unsigned char src_str[128];
5903  unsigned char dst_str[257];
5904  unsigned char iv_str[128];
5905  unsigned char add_str[128];
5906  unsigned char tag_str[128];
5907  unsigned char output[128];
5908  gcm_context ctx;
5909  unsigned int key_len;
5910  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
5911  int ret;
5912 
5913  memset(key_str, 0x00, 128);
5914  memset(src_str, 0x00, 128);
5915  memset(dst_str, 0x00, 257);
5916  memset(iv_str, 0x00, 128);
5917  memset(add_str, 0x00, 128);
5918  memset(tag_str, 0x00, 128);
5919  memset(output, 0x00, 128);
5920 
5921  key_len = unhexify( key_str, "389cf888474e9403e5f4d0e22ffec439" );
5922  pt_len = unhexify( src_str, "" );
5923  iv_len = unhexify( iv_str, "ef57794cf6fac9f9cea3e8499b53b1d6" );
5924  add_len = unhexify( add_str, "7ea7f7f4763ad208eb6199285b6b2819756c4e3caf2d0ac6f5076ae6785fecdcc4b138a51860ff8b87aaac3a18c2df778a4818308d458dba28f5017513e1454f60be20dae68736ea6d48b1f9deadb517df63140acbd329fbfbc9b82f3ca1862c9e998f0faff1d3ae60b005bf66829f5cf0c5fa03efbdd92d39351e3954be0257" );
5925  unhexify( tag_str, "92726d90ad26130e65f2beb4" );
5926 
5927  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5928  if( 0 == 0 )
5929  {
5930  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5931 
5932  if( strcmp( "FAIL", "FAIL" ) == 0 )
5933  {
5934  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5935  }
5936  else
5937  {
5938  hexify( dst_str, output, pt_len );
5939 
5940  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
5941  }
5942  }
5943  }
5944  FCT_TEST_END();
5945 
5946 
5947  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102496_2)
5948  {
5949  unsigned char key_str[128];
5950  unsigned char src_str[128];
5951  unsigned char dst_str[257];
5952  unsigned char iv_str[128];
5953  unsigned char add_str[128];
5954  unsigned char tag_str[128];
5955  unsigned char output[128];
5956  gcm_context ctx;
5957  unsigned int key_len;
5958  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
5959  int ret;
5960 
5961  memset(key_str, 0x00, 128);
5962  memset(src_str, 0x00, 128);
5963  memset(dst_str, 0x00, 257);
5964  memset(iv_str, 0x00, 128);
5965  memset(add_str, 0x00, 128);
5966  memset(tag_str, 0x00, 128);
5967  memset(output, 0x00, 128);
5968 
5969  key_len = unhexify( key_str, "e55abb2ca36c822bf2a030ac703cb8b4" );
5970  pt_len = unhexify( src_str, "" );
5971  iv_len = unhexify( iv_str, "d86f7177e8ec90f9e9edf10175d5012d" );
5972  add_len = unhexify( add_str, "777a9d93091de56324c10712243f5541722e0b27e1f303fef6faa387a8666161ab354dbea6c43c82a24e8623bfec39aab13164add6be0dfd55d23204c0975b4ba6fbda51363befde482a9ccc1eb9f151e6ad59c77a1e24dd268389e4686f198a936dd603044a3fb653d63cff80597f5a2913c8a2ec1b7d9dce5728dd56c78c2c" );
5973  unhexify( tag_str, "65025250343ed8c09b3fceed" );
5974 
5975  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
5976  if( 0 == 0 )
5977  {
5978  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
5979 
5980  if( strcmp( "FAIL", "" ) == 0 )
5981  {
5982  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
5983  }
5984  else
5985  {
5986  hexify( dst_str, output, pt_len );
5987 
5988  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
5989  }
5990  }
5991  }
5992  FCT_TEST_END();
5993 
5994 
5995  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102464_0)
5996  {
5997  unsigned char key_str[128];
5998  unsigned char src_str[128];
5999  unsigned char dst_str[257];
6000  unsigned char iv_str[128];
6001  unsigned char add_str[128];
6002  unsigned char tag_str[128];
6003  unsigned char output[128];
6004  gcm_context ctx;
6005  unsigned int key_len;
6006  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
6007  int ret;
6008 
6009  memset(key_str, 0x00, 128);
6010  memset(src_str, 0x00, 128);
6011  memset(dst_str, 0x00, 257);
6012  memset(iv_str, 0x00, 128);
6013  memset(add_str, 0x00, 128);
6014  memset(tag_str, 0x00, 128);
6015  memset(output, 0x00, 128);
6016 
6017  key_len = unhexify( key_str, "586114f3b1dc087e1b2739b28c592dfe" );
6018  pt_len = unhexify( src_str, "" );
6019  iv_len = unhexify( iv_str, "ae5a38ddd455505284434a4bcfe81ef2" );
6020  add_len = unhexify( add_str, "531ff8c285e532d961f49bd210a5523cd9b19a697a3a3fb26db940a496f253862405b1e825daeda7eb0445c98022b8342c8f8ea20301618483f8ab04b6ebccd7e7fc57878fb544a5bf78fa896f50ac30126ff8afca8a86388666b64c643d16812729bfd7e5c03ba52f7e6ea4c6a685404f7bcbd956964417fa0ea9a6d7290c41" );
6021  unhexify( tag_str, "467a815610faeb82" );
6022 
6023  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6024  if( 0 == 0 )
6025  {
6026  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6027 
6028  if( strcmp( "FAIL", "" ) == 0 )
6029  {
6030  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6031  }
6032  else
6033  {
6034  hexify( dst_str, output, pt_len );
6035 
6036  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
6037  }
6038  }
6039  }
6040  FCT_TEST_END();
6041 
6042 
6043  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102464_1)
6044  {
6045  unsigned char key_str[128];
6046  unsigned char src_str[128];
6047  unsigned char dst_str[257];
6048  unsigned char iv_str[128];
6049  unsigned char add_str[128];
6050  unsigned char tag_str[128];
6051  unsigned char output[128];
6052  gcm_context ctx;
6053  unsigned int key_len;
6054  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
6055  int ret;
6056 
6057  memset(key_str, 0x00, 128);
6058  memset(src_str, 0x00, 128);
6059  memset(dst_str, 0x00, 257);
6060  memset(iv_str, 0x00, 128);
6061  memset(add_str, 0x00, 128);
6062  memset(tag_str, 0x00, 128);
6063  memset(output, 0x00, 128);
6064 
6065  key_len = unhexify( key_str, "cbfe806bddb7f06b3826b097550c68f5" );
6066  pt_len = unhexify( src_str, "" );
6067  iv_len = unhexify( iv_str, "04c1b6c9fd2ab76fc2adfe15d3421bbb" );
6068  add_len = unhexify( add_str, "cfa86d02599652cb4ffff027b9c6ef2336dc9fe946f64fa5ce83f624e144563d4738381bc5371c3cb55cf41ceda07e62cb635ff37246bfa428785229c6e869d5df69d7949a8577889a29e3d05b788ddd43608d9c14e3f1b51ce2085b9a976fe843e3396a74922babe6797d5f01c37ead623b5b582505bcd29edf8a6ea36b0fc7" );
6069  unhexify( tag_str, "0697ac372a9acafd" );
6070 
6071  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6072  if( 0 == 0 )
6073  {
6074  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6075 
6076  if( strcmp( "FAIL", "" ) == 0 )
6077  {
6078  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6079  }
6080  else
6081  {
6082  hexify( dst_str, output, pt_len );
6083 
6084  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
6085  }
6086  }
6087  }
6088  FCT_TEST_END();
6089 
6090 
6091  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102464_2)
6092  {
6093  unsigned char key_str[128];
6094  unsigned char src_str[128];
6095  unsigned char dst_str[257];
6096  unsigned char iv_str[128];
6097  unsigned char add_str[128];
6098  unsigned char tag_str[128];
6099  unsigned char output[128];
6100  gcm_context ctx;
6101  unsigned int key_len;
6102  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
6103  int ret;
6104 
6105  memset(key_str, 0x00, 128);
6106  memset(src_str, 0x00, 128);
6107  memset(dst_str, 0x00, 257);
6108  memset(iv_str, 0x00, 128);
6109  memset(add_str, 0x00, 128);
6110  memset(tag_str, 0x00, 128);
6111  memset(output, 0x00, 128);
6112 
6113  key_len = unhexify( key_str, "96ce3a095a91effdd91d616f1f02ddcd" );
6114  pt_len = unhexify( src_str, "" );
6115  iv_len = unhexify( iv_str, "579d6633ec6687afa24ef874899b58e0" );
6116  add_len = unhexify( add_str, "3ff3c0038148ed391b6a10aad623a82fe9209c5ba74482f11506d597b5fc7af977235d8ee9e28cf2160346ddd0e33a5bd1fb67b87dad7167fdd4b2b4000d8460ef7b3e1b59b9d61d06cfbe7945379ed6b650de86f396a38cc70d47b8a349f067d00144c903c276b323be6a929a7d7dd8ae7d254d640cdc1176f98e01a1d8c82f" );
6117  unhexify( tag_str, "55a0f61032e048f3" );
6118 
6119  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6120  if( 0 == 0 )
6121  {
6122  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6123 
6124  if( strcmp( "FAIL", "FAIL" ) == 0 )
6125  {
6126  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6127  }
6128  else
6129  {
6130  hexify( dst_str, output, pt_len );
6131 
6132  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
6133  }
6134  }
6135  }
6136  FCT_TEST_END();
6137 
6138 
6139  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102432_0)
6140  {
6141  unsigned char key_str[128];
6142  unsigned char src_str[128];
6143  unsigned char dst_str[257];
6144  unsigned char iv_str[128];
6145  unsigned char add_str[128];
6146  unsigned char tag_str[128];
6147  unsigned char output[128];
6148  gcm_context ctx;
6149  unsigned int key_len;
6150  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
6151  int ret;
6152 
6153  memset(key_str, 0x00, 128);
6154  memset(src_str, 0x00, 128);
6155  memset(dst_str, 0x00, 257);
6156  memset(iv_str, 0x00, 128);
6157  memset(add_str, 0x00, 128);
6158  memset(tag_str, 0x00, 128);
6159  memset(output, 0x00, 128);
6160 
6161  key_len = unhexify( key_str, "24ece168c2971cf2b404ea206dc9e29d" );
6162  pt_len = unhexify( src_str, "" );
6163  iv_len = unhexify( iv_str, "e9db62a42491664a6c46cbb0b2bafc92" );
6164  add_len = unhexify( add_str, "3579f6c0cb3d2a5d0c4548855c7c052d36b6a8dfc60f4ca1b4bbe28ed87306119e71982dd84c4205ceba918d675472753df1b5192d3693dbf6a061c6056e312135ffc5ff426895a7e30f7f675d2cb21de06eea5e3761b94deef7537b985d324864c9ff6ab6e230a1006720f98c958912b604a6d03e3979887c07be3ceaafc78f" );
6165  unhexify( tag_str, "d2b15a23" );
6166 
6167  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6168  if( 0 == 0 )
6169  {
6170  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6171 
6172  if( strcmp( "FAIL", "FAIL" ) == 0 )
6173  {
6174  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6175  }
6176  else
6177  {
6178  hexify( dst_str, output, pt_len );
6179 
6180  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
6181  }
6182  }
6183  }
6184  FCT_TEST_END();
6185 
6186 
6187  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102432_1)
6188  {
6189  unsigned char key_str[128];
6190  unsigned char src_str[128];
6191  unsigned char dst_str[257];
6192  unsigned char iv_str[128];
6193  unsigned char add_str[128];
6194  unsigned char tag_str[128];
6195  unsigned char output[128];
6196  gcm_context ctx;
6197  unsigned int key_len;
6198  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
6199  int ret;
6200 
6201  memset(key_str, 0x00, 128);
6202  memset(src_str, 0x00, 128);
6203  memset(dst_str, 0x00, 257);
6204  memset(iv_str, 0x00, 128);
6205  memset(add_str, 0x00, 128);
6206  memset(tag_str, 0x00, 128);
6207  memset(output, 0x00, 128);
6208 
6209  key_len = unhexify( key_str, "d3c3cf993f6740a019e61ce13c29955c" );
6210  pt_len = unhexify( src_str, "" );
6211  iv_len = unhexify( iv_str, "af900ac348082ff32d2e0ab886079516" );
6212  add_len = unhexify( add_str, "2ddd0e8c99661f0757f04aa79a1ffa24ad48fbe5da68b9e71f7a0cf1b4f2ca9b757695900b7549d48847ae49950dc9b270b1569d29dcbef412216737bd83509c17ae41c34ccda318939cb37a0a380762993a7568c0b07794e78746173dd5c0d921cd50de4b548c1589e142c3dadbad42161aaeda2310f3c6d5c722d9ac69e96d" );
6213  unhexify( tag_str, "f2d3a6ff" );
6214 
6215  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6216  if( 0 == 0 )
6217  {
6218  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6219 
6220  if( strcmp( "FAIL", "FAIL" ) == 0 )
6221  {
6222  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6223  }
6224  else
6225  {
6226  hexify( dst_str, output, pt_len );
6227 
6228  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
6229  }
6230  }
6231  }
6232  FCT_TEST_END();
6233 
6234 
6235  FCT_TEST_BGN(gcm_nist_validation_aes_1281280102432_2)
6236  {
6237  unsigned char key_str[128];
6238  unsigned char src_str[128];
6239  unsigned char dst_str[257];
6240  unsigned char iv_str[128];
6241  unsigned char add_str[128];
6242  unsigned char tag_str[128];
6243  unsigned char output[128];
6244  gcm_context ctx;
6245  unsigned int key_len;
6246  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
6247  int ret;
6248 
6249  memset(key_str, 0x00, 128);
6250  memset(src_str, 0x00, 128);
6251  memset(dst_str, 0x00, 257);
6252  memset(iv_str, 0x00, 128);
6253  memset(add_str, 0x00, 128);
6254  memset(tag_str, 0x00, 128);
6255  memset(output, 0x00, 128);
6256 
6257  key_len = unhexify( key_str, "5f1e5bd45ee8bb207ebbd730510ff218" );
6258  pt_len = unhexify( src_str, "" );
6259  iv_len = unhexify( iv_str, "8846424a194f5de858556e6be5b65d7f" );
6260  add_len = unhexify( add_str, "e968947fc0e49136e730b97f6b16e393d5e4fdf3e4803a23af79211ef59f29167c60ead72fd489da32d2ffa43b2bca2074f9d1b4f5396ca65004b0806cb7c6dfa751fb6afbee3e443f3c9b0e3df6722e0d1320441400c5ca508afb657c2b7f1669b0de21761dccab9a40fc513768bd1f552692626ce35078a2e0e12f5d930647" );
6261  unhexify( tag_str, "0d6c15da" );
6262 
6263  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6264  if( 0 == 0 )
6265  {
6266  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6267 
6268  if( strcmp( "FAIL", "" ) == 0 )
6269  {
6270  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6271  }
6272  else
6273  {
6274  hexify( dst_str, output, pt_len );
6275 
6276  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
6277  }
6278  }
6279  }
6280  FCT_TEST_END();
6281 
6282 
6283  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240128_0)
6284  {
6285  unsigned char key_str[128];
6286  unsigned char src_str[128];
6287  unsigned char dst_str[257];
6288  unsigned char iv_str[128];
6289  unsigned char add_str[128];
6290  unsigned char tag_str[128];
6291  unsigned char output[128];
6292  gcm_context ctx;
6293  unsigned int key_len;
6294  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
6295  int ret;
6296 
6297  memset(key_str, 0x00, 128);
6298  memset(src_str, 0x00, 128);
6299  memset(dst_str, 0x00, 257);
6300  memset(iv_str, 0x00, 128);
6301  memset(add_str, 0x00, 128);
6302  memset(tag_str, 0x00, 128);
6303  memset(output, 0x00, 128);
6304 
6305  key_len = unhexify( key_str, "3997050377cfbb802cc438d973661688" );
6306  pt_len = unhexify( src_str, "b02f0dd373e42c65e8e1db2dd76a432e0b2bf6e630c8aaf0d48af51b3709b175de9a19b3245ae75818274c771c06fae225c4f8b002236712336e805ab006449eb29cc5e29abd82b06c32d4c36ee99acb9a6d7d9eae6ec6ec263c002a22c4a898c74f6abd6d92112367ca7ffe82787c5b39e7012ba22825d3612af3d41e8008a8" );
6307  iv_len = unhexify( iv_str, "c95c84c263bdfd5f1de66e7e616cf3fb" );
6308  add_len = unhexify( add_str, "" );
6309  unhexify( tag_str, "b35b3cf6ed59ccb69dbc9b47a3f284ae" );
6310 
6311  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6312  if( 0 == 0 )
6313  {
6314  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6315 
6316  if( strcmp( "FAIL", "FAIL" ) == 0 )
6317  {
6318  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6319  }
6320  else
6321  {
6322  hexify( dst_str, output, pt_len );
6323 
6324  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
6325  }
6326  }
6327  }
6328  FCT_TEST_END();
6329 
6330 
6331  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240128_1)
6332  {
6333  unsigned char key_str[128];
6334  unsigned char src_str[128];
6335  unsigned char dst_str[257];
6336  unsigned char iv_str[128];
6337  unsigned char add_str[128];
6338  unsigned char tag_str[128];
6339  unsigned char output[128];
6340  gcm_context ctx;
6341  unsigned int key_len;
6342  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
6343  int ret;
6344 
6345  memset(key_str, 0x00, 128);
6346  memset(src_str, 0x00, 128);
6347  memset(dst_str, 0x00, 257);
6348  memset(iv_str, 0x00, 128);
6349  memset(add_str, 0x00, 128);
6350  memset(tag_str, 0x00, 128);
6351  memset(output, 0x00, 128);
6352 
6353  key_len = unhexify( key_str, "c58583f6479d9bc9f1bffddefee66e59" );
6354  pt_len = unhexify( src_str, "564a9f700cbc1f895e4f4fa6426f73b4956896a15e6127e7560d74e3fd0b980d2ee45b7a6a3884fa613d91d13921e3f90967d7132bdafcd146dd8ff7147ed1964c2bdb3e12f4133d3dbbc3bf030ff37b1d2147c493ce885068d9ba5bebae24903aaac004aa0ab73fe789e4150e75ddc2bde2700db02e6398d53e88ac652964ac" );
6355  iv_len = unhexify( iv_str, "cee448b48d3506ff3ecc227a87987846" );
6356  add_len = unhexify( add_str, "" );
6357  unhexify( tag_str, "361fc2896d7ee986ecef7cbe665bc60c" );
6358 
6359  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6360  if( 0 == 0 )
6361  {
6362  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6363 
6364  if( strcmp( "FAIL", "9cce7db3fc087d8cb384f6b1a81f03b3fafa2e3281e9f0fcf08a8283929f32439bb0d302516f0ab65b79181fc223a42345bad6e46ff8bcb55add90207f74481227f71a6230a3e13739ef2d015f5003638234b01e58537b7cfab5a8edac19721f41d46948987d1bb1b1d9485a672647bb3b5cb246a1d753a0d107bff036ac7d95" ) == 0 )
6365  {
6366  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6367  }
6368  else
6369  {
6370  hexify( dst_str, output, pt_len );
6371 
6372  fct_chk( strcmp( (char *) dst_str, "9cce7db3fc087d8cb384f6b1a81f03b3fafa2e3281e9f0fcf08a8283929f32439bb0d302516f0ab65b79181fc223a42345bad6e46ff8bcb55add90207f74481227f71a6230a3e13739ef2d015f5003638234b01e58537b7cfab5a8edac19721f41d46948987d1bb1b1d9485a672647bb3b5cb246a1d753a0d107bff036ac7d95" ) == 0 );
6373  }
6374  }
6375  }
6376  FCT_TEST_END();
6377 
6378 
6379  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240128_2)
6380  {
6381  unsigned char key_str[128];
6382  unsigned char src_str[128];
6383  unsigned char dst_str[257];
6384  unsigned char iv_str[128];
6385  unsigned char add_str[128];
6386  unsigned char tag_str[128];
6387  unsigned char output[128];
6388  gcm_context ctx;
6389  unsigned int key_len;
6390  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
6391  int ret;
6392 
6393  memset(key_str, 0x00, 128);
6394  memset(src_str, 0x00, 128);
6395  memset(dst_str, 0x00, 257);
6396  memset(iv_str, 0x00, 128);
6397  memset(add_str, 0x00, 128);
6398  memset(tag_str, 0x00, 128);
6399  memset(output, 0x00, 128);
6400 
6401  key_len = unhexify( key_str, "0bc2bde877e881aea512068105694968" );
6402  pt_len = unhexify( src_str, "1a6369a45e8ef2846c42d54f92d0d140a94f9633432782dcbf094f1444a1d006acd07ef6076cd0faee226f9ff14adc1fb23e3c63ed818c9a743efbe16624981663e5a64f03f411dcd326e0c259bcadca3b3dd7660ed985c1b77f13a3b232a5934f8b54e46f8368c6e6eb75f933196fa973e7413e4b1442b9dee5e265b44255ed" );
6403  iv_len = unhexify( iv_str, "05f0c34ab2e8e8026b0a23719344b71f" );
6404  add_len = unhexify( add_str, "" );
6405  unhexify( tag_str, "46bab9fc2dbe87b8f6ca0ed4d73e5368" );
6406 
6407  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6408  if( 0 == 0 )
6409  {
6410  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6411 
6412  if( strcmp( "FAIL", "FAIL" ) == 0 )
6413  {
6414  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6415  }
6416  else
6417  {
6418  hexify( dst_str, output, pt_len );
6419 
6420  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
6421  }
6422  }
6423  }
6424  FCT_TEST_END();
6425 
6426 
6427  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240120_0)
6428  {
6429  unsigned char key_str[128];
6430  unsigned char src_str[128];
6431  unsigned char dst_str[257];
6432  unsigned char iv_str[128];
6433  unsigned char add_str[128];
6434  unsigned char tag_str[128];
6435  unsigned char output[128];
6436  gcm_context ctx;
6437  unsigned int key_len;
6438  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
6439  int ret;
6440 
6441  memset(key_str, 0x00, 128);
6442  memset(src_str, 0x00, 128);
6443  memset(dst_str, 0x00, 257);
6444  memset(iv_str, 0x00, 128);
6445  memset(add_str, 0x00, 128);
6446  memset(tag_str, 0x00, 128);
6447  memset(output, 0x00, 128);
6448 
6449  key_len = unhexify( key_str, "e14f45ba5d1eb52e0412240da5d7b5f9" );
6450  pt_len = unhexify( src_str, "9a85fda19ce923f093a0c25b0c52f5d9534828af7c7687d22307004ae2d10c4592242c0f2704070307ab55b137780d1e2013a19396ab43ff6a295b63fdcf323456d149758f9a2bb37f1418d62ea6368b24d5067b9c63d2968e06d6586c7e3275faffa005f7c7bfef51303e4c2b2ed4564acd17d50efac9f5e3e7f16ce589c39b" );
6451  iv_len = unhexify( iv_str, "d7f8ef12f66f8b7c60aea02ef6ff688f" );
6452  add_len = unhexify( add_str, "" );
6453  unhexify( tag_str, "beede05e4928c808bc660f3de95634" );
6454 
6455  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6456  if( 0 == 0 )
6457  {
6458  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6459 
6460  if( strcmp( "FAIL", "4ad5b9ace0c0c7c07df2900faf37a902899471e7aa4a0a1ad5387f8f56d73f78f619be79a4e253f95b15d52895a05bae9ecffa916d35efacd8baf1c704d2aa4a38c234efc4dcfb191ec0fa0b522328fa5b5dff55e8c443fee660ebe3d8ad85de157a889aefc823720030a4cd6ba94a6309dd61806f0abb27772432018bc61701" ) == 0 )
6461  {
6462  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6463  }
6464  else
6465  {
6466  hexify( dst_str, output, pt_len );
6467 
6468  fct_chk( strcmp( (char *) dst_str, "4ad5b9ace0c0c7c07df2900faf37a902899471e7aa4a0a1ad5387f8f56d73f78f619be79a4e253f95b15d52895a05bae9ecffa916d35efacd8baf1c704d2aa4a38c234efc4dcfb191ec0fa0b522328fa5b5dff55e8c443fee660ebe3d8ad85de157a889aefc823720030a4cd6ba94a6309dd61806f0abb27772432018bc61701" ) == 0 );
6469  }
6470  }
6471  }
6472  FCT_TEST_END();
6473 
6474 
6475  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240120_1)
6476  {
6477  unsigned char key_str[128];
6478  unsigned char src_str[128];
6479  unsigned char dst_str[257];
6480  unsigned char iv_str[128];
6481  unsigned char add_str[128];
6482  unsigned char tag_str[128];
6483  unsigned char output[128];
6484  gcm_context ctx;
6485  unsigned int key_len;
6486  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
6487  int ret;
6488 
6489  memset(key_str, 0x00, 128);
6490  memset(src_str, 0x00, 128);
6491  memset(dst_str, 0x00, 257);
6492  memset(iv_str, 0x00, 128);
6493  memset(add_str, 0x00, 128);
6494  memset(tag_str, 0x00, 128);
6495  memset(output, 0x00, 128);
6496 
6497  key_len = unhexify( key_str, "9a64579f3601b0022d357b601cd876ab" );
6498  pt_len = unhexify( src_str, "88be1f4bc8c81b8a9d7abc073cb2751e209ab6b912c15dc094002f95a57a660b9f08b1b34f5947223205b579e704d70a9ecb54520ce3491e52965be643f729516f5cb018beeedc68a7d66c0d40a3f392ec7729c566ce1e9f964c4c0bd61b291ccb96e3d1fac18a401a302f3775697c71edb8ff5a8275a815eba9dd3b912e3759" );
6499  iv_len = unhexify( iv_str, "515efc6d036f95db7df56b1bbec0aff2" );
6500  add_len = unhexify( add_str, "" );
6501  unhexify( tag_str, "13ea92ba35fced366d1e47c97ca5c9" );
6502 
6503  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6504  if( 0 == 0 )
6505  {
6506  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6507 
6508  if( strcmp( "FAIL", "7fc8565760c168d640f24896c69758355b17310dbc359f38b73fc7b57fe3f4b6ecad3f298be931c96a639df3c5744f7e932b32d222f5534efb8eb5d5b98d218dce3efef5c8c7ce65738bf63412d0a8ed209071218a6fa2f7be79b38d0b2f5b571ec73f1a91721bd409b1722b313683e97d53df19ded95fd471124fa5f294a4bb" ) == 0 )
6509  {
6510  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6511  }
6512  else
6513  {
6514  hexify( dst_str, output, pt_len );
6515 
6516  fct_chk( strcmp( (char *) dst_str, "7fc8565760c168d640f24896c69758355b17310dbc359f38b73fc7b57fe3f4b6ecad3f298be931c96a639df3c5744f7e932b32d222f5534efb8eb5d5b98d218dce3efef5c8c7ce65738bf63412d0a8ed209071218a6fa2f7be79b38d0b2f5b571ec73f1a91721bd409b1722b313683e97d53df19ded95fd471124fa5f294a4bb" ) == 0 );
6517  }
6518  }
6519  }
6520  FCT_TEST_END();
6521 
6522 
6523  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240120_2)
6524  {
6525  unsigned char key_str[128];
6526  unsigned char src_str[128];
6527  unsigned char dst_str[257];
6528  unsigned char iv_str[128];
6529  unsigned char add_str[128];
6530  unsigned char tag_str[128];
6531  unsigned char output[128];
6532  gcm_context ctx;
6533  unsigned int key_len;
6534  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
6535  int ret;
6536 
6537  memset(key_str, 0x00, 128);
6538  memset(src_str, 0x00, 128);
6539  memset(dst_str, 0x00, 257);
6540  memset(iv_str, 0x00, 128);
6541  memset(add_str, 0x00, 128);
6542  memset(tag_str, 0x00, 128);
6543  memset(output, 0x00, 128);
6544 
6545  key_len = unhexify( key_str, "1bda4acfd10ab635f357935bb0ab7020" );
6546  pt_len = unhexify( src_str, "c9ac8d4ef7d83848fdc03664957c28b9b76710797d5db1c21e713e85eb0898892223e52be1644fc7362c95026ebb9c9ca74d7d3739eff10cab1eda00c36628dae0b98d119a14635800e37cd340faa6fbba9c3d41d52722cc3969612b1a8c5ca9a68773f5ee654506cb88ea65fb1eddf5ab6312d0170dc03324e483342448b854" );
6547  iv_len = unhexify( iv_str, "48b77c587616ffaa449533a91230b449" );
6548  add_len = unhexify( add_str, "" );
6549  unhexify( tag_str, "8325e4394c91719691145e68e56439" );
6550 
6551  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6552  if( 0 == 0 )
6553  {
6554  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6555 
6556  if( strcmp( "FAIL", "1287ad3719508a9be70c19e3b134a2eaa4415d736c55922e9abcfd7f621ea07ffb9b78d8a9668c74bbd548b5e6519ea12609d2d6197c8bd3da9c13c46628f218e7ff81884ff7eb34664ab00f86e09cd623bec248d8898ef054fce8f718a0e0978e8b5d037709c524114ec37809ac3fd1604e223e08f594e7aa12097f7dc1850b" ) == 0 )
6557  {
6558  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6559  }
6560  else
6561  {
6562  hexify( dst_str, output, pt_len );
6563 
6564  fct_chk( strcmp( (char *) dst_str, "1287ad3719508a9be70c19e3b134a2eaa4415d736c55922e9abcfd7f621ea07ffb9b78d8a9668c74bbd548b5e6519ea12609d2d6197c8bd3da9c13c46628f218e7ff81884ff7eb34664ab00f86e09cd623bec248d8898ef054fce8f718a0e0978e8b5d037709c524114ec37809ac3fd1604e223e08f594e7aa12097f7dc1850b" ) == 0 );
6565  }
6566  }
6567  }
6568  FCT_TEST_END();
6569 
6570 
6571  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240112_0)
6572  {
6573  unsigned char key_str[128];
6574  unsigned char src_str[128];
6575  unsigned char dst_str[257];
6576  unsigned char iv_str[128];
6577  unsigned char add_str[128];
6578  unsigned char tag_str[128];
6579  unsigned char output[128];
6580  gcm_context ctx;
6581  unsigned int key_len;
6582  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
6583  int ret;
6584 
6585  memset(key_str, 0x00, 128);
6586  memset(src_str, 0x00, 128);
6587  memset(dst_str, 0x00, 257);
6588  memset(iv_str, 0x00, 128);
6589  memset(add_str, 0x00, 128);
6590  memset(tag_str, 0x00, 128);
6591  memset(output, 0x00, 128);
6592 
6593  key_len = unhexify( key_str, "d21cf24bc5bd176b4b0fd4c8477bb70d" );
6594  pt_len = unhexify( src_str, "2e7108fd25c88b799263791940594ec80b26ccd53455c837b2e6cf4e27fcf9707af3f0fe311355e1b03ac3b5ee0af09fb6fb9f0311f8545d40a658119e6a87ba8ba72cc5fdb1386bc455c8fec51a7c0fec957bed4d6441180741197962d51b17c393b57553e53602f2a343a0871ea2dc4b1506663b2768ce271b89c4ed99eec6" );
6595  iv_len = unhexify( iv_str, "208cb9dced20b18edddb91596e902124" );
6596  add_len = unhexify( add_str, "" );
6597  unhexify( tag_str, "7edfb9daf8ca2babcc02537463e9" );
6598 
6599  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6600  if( 0 == 0 )
6601  {
6602  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6603 
6604  if( strcmp( "FAIL", "FAIL" ) == 0 )
6605  {
6606  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6607  }
6608  else
6609  {
6610  hexify( dst_str, output, pt_len );
6611 
6612  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
6613  }
6614  }
6615  }
6616  FCT_TEST_END();
6617 
6618 
6619  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240112_1)
6620  {
6621  unsigned char key_str[128];
6622  unsigned char src_str[128];
6623  unsigned char dst_str[257];
6624  unsigned char iv_str[128];
6625  unsigned char add_str[128];
6626  unsigned char tag_str[128];
6627  unsigned char output[128];
6628  gcm_context ctx;
6629  unsigned int key_len;
6630  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
6631  int ret;
6632 
6633  memset(key_str, 0x00, 128);
6634  memset(src_str, 0x00, 128);
6635  memset(dst_str, 0x00, 257);
6636  memset(iv_str, 0x00, 128);
6637  memset(add_str, 0x00, 128);
6638  memset(tag_str, 0x00, 128);
6639  memset(output, 0x00, 128);
6640 
6641  key_len = unhexify( key_str, "3d02e2b02170986944487cba8448f998" );
6642  pt_len = unhexify( src_str, "bc1d7553f4a28754cf59ed6f7a901901f04ce62a449db2b45ad60329d0341bb9ba421c783c28a9200b41da8ab6328d826293134a7d0c9a5775dd2735e7767efda4ad183566e0847d6d978abd1a8ab13b16b8323acef05ced3b571631e1e24ad44d65e6ffa64e03c9970e94bacb9f721aba06cda6a08806a3be63dddd8029301d" );
6643  iv_len = unhexify( iv_str, "6336077bb83eff1c9ea715de99b372cd" );
6644  add_len = unhexify( add_str, "" );
6645  unhexify( tag_str, "0466bb2957281f64b59eafed3509" );
6646 
6647  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6648  if( 0 == 0 )
6649  {
6650  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6651 
6652  if( strcmp( "FAIL", "5f395958f2f7acafb1bca6d3a6ec48b717f2ceeac1b77e1b0edc09a09e4a299d2ec722cc7daf34c8f4121a93c80b2adb20a2fc95afd09320f91085c93c8b082dd703814c9777501d23bf9b328f07f04652592dc5a3f4321626a695b8db8e65c8617c809eb2978d8c9a882ffa82a4bb707c1a8f9a965bdacce5c041bafc94a1c6" ) == 0 )
6653  {
6654  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6655  }
6656  else
6657  {
6658  hexify( dst_str, output, pt_len );
6659 
6660  fct_chk( strcmp( (char *) dst_str, "5f395958f2f7acafb1bca6d3a6ec48b717f2ceeac1b77e1b0edc09a09e4a299d2ec722cc7daf34c8f4121a93c80b2adb20a2fc95afd09320f91085c93c8b082dd703814c9777501d23bf9b328f07f04652592dc5a3f4321626a695b8db8e65c8617c809eb2978d8c9a882ffa82a4bb707c1a8f9a965bdacce5c041bafc94a1c6" ) == 0 );
6661  }
6662  }
6663  }
6664  FCT_TEST_END();
6665 
6666 
6667  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240112_2)
6668  {
6669  unsigned char key_str[128];
6670  unsigned char src_str[128];
6671  unsigned char dst_str[257];
6672  unsigned char iv_str[128];
6673  unsigned char add_str[128];
6674  unsigned char tag_str[128];
6675  unsigned char output[128];
6676  gcm_context ctx;
6677  unsigned int key_len;
6678  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
6679  int ret;
6680 
6681  memset(key_str, 0x00, 128);
6682  memset(src_str, 0x00, 128);
6683  memset(dst_str, 0x00, 257);
6684  memset(iv_str, 0x00, 128);
6685  memset(add_str, 0x00, 128);
6686  memset(tag_str, 0x00, 128);
6687  memset(output, 0x00, 128);
6688 
6689  key_len = unhexify( key_str, "cd1ad1de0521d41645d13c97a18f4a20" );
6690  pt_len = unhexify( src_str, "588c2617517329f3e1e7ba6206a183dc9232e6a4fa8c8b89532d46235af1e542acaa7eae4d034f139b00449076ba2ef9a692cae422998878dabdac60993dce9880d280bec1419803ba937366e5285c4a7f31a5f232f8d3ef73efe7267b3ef82a02f97d320ebc9db6219fbdf1c7f611e8e5164e9ecf25b32f9c07dfa12aa705af" );
6691  iv_len = unhexify( iv_str, "413873a0b063ad039da5513896233286" );
6692  add_len = unhexify( add_str, "" );
6693  unhexify( tag_str, "d4dbe9cae116553b0cbe1984d176" );
6694 
6695  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6696  if( 0 == 0 )
6697  {
6698  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6699 
6700  if( strcmp( "FAIL", "bd519b7e6921e6026784cd7b836c89bc1fa98e4013b41d2bf091ef0d602e44a70df89816c068d37f0c6377af46c8bfa73ec0d5bc0b61966f23e55a15a83cea49f37cc02213b4996f9353ee2b73a798b626e524b9c15937ecf98a4eded83fb62e6deea1de31e0a7f1d210f6d964bc3e69b269da834720fd33487874489b8932a8" ) == 0 )
6701  {
6702  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6703  }
6704  else
6705  {
6706  hexify( dst_str, output, pt_len );
6707 
6708  fct_chk( strcmp( (char *) dst_str, "bd519b7e6921e6026784cd7b836c89bc1fa98e4013b41d2bf091ef0d602e44a70df89816c068d37f0c6377af46c8bfa73ec0d5bc0b61966f23e55a15a83cea49f37cc02213b4996f9353ee2b73a798b626e524b9c15937ecf98a4eded83fb62e6deea1de31e0a7f1d210f6d964bc3e69b269da834720fd33487874489b8932a8" ) == 0 );
6709  }
6710  }
6711  }
6712  FCT_TEST_END();
6713 
6714 
6715  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240104_0)
6716  {
6717  unsigned char key_str[128];
6718  unsigned char src_str[128];
6719  unsigned char dst_str[257];
6720  unsigned char iv_str[128];
6721  unsigned char add_str[128];
6722  unsigned char tag_str[128];
6723  unsigned char output[128];
6724  gcm_context ctx;
6725  unsigned int key_len;
6726  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
6727  int ret;
6728 
6729  memset(key_str, 0x00, 128);
6730  memset(src_str, 0x00, 128);
6731  memset(dst_str, 0x00, 257);
6732  memset(iv_str, 0x00, 128);
6733  memset(add_str, 0x00, 128);
6734  memset(tag_str, 0x00, 128);
6735  memset(output, 0x00, 128);
6736 
6737  key_len = unhexify( key_str, "1cb120e9cd718b5119b4a58af0644eff" );
6738  pt_len = unhexify( src_str, "4c8e8fb8c87ff6b994ae71bfbf0fa4529f03bad86edf9d27cf899ea93a32972640697e00546136c1dbc7e63662200951b6479c58ae26b1bd8c3b4f507c0d945d615183196868ec4f4865d1d00bb919a00184e9663f6cb9a7a0ddfc73ee2901f7a56ef2074d554f48cef254be558fca35651be405f91c39e0367762b4715d05fa" );
6739  iv_len = unhexify( iv_str, "5a7087989bfe2f6eddcb56fde4d72529" );
6740  add_len = unhexify( add_str, "" );
6741  unhexify( tag_str, "95d8bd12af8a5ab677309df0fb" );
6742 
6743  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6744  if( 0 == 0 )
6745  {
6746  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6747 
6748  if( strcmp( "FAIL", "FAIL" ) == 0 )
6749  {
6750  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6751  }
6752  else
6753  {
6754  hexify( dst_str, output, pt_len );
6755 
6756  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
6757  }
6758  }
6759  }
6760  FCT_TEST_END();
6761 
6762 
6763  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240104_1)
6764  {
6765  unsigned char key_str[128];
6766  unsigned char src_str[128];
6767  unsigned char dst_str[257];
6768  unsigned char iv_str[128];
6769  unsigned char add_str[128];
6770  unsigned char tag_str[128];
6771  unsigned char output[128];
6772  gcm_context ctx;
6773  unsigned int key_len;
6774  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
6775  int ret;
6776 
6777  memset(key_str, 0x00, 128);
6778  memset(src_str, 0x00, 128);
6779  memset(dst_str, 0x00, 257);
6780  memset(iv_str, 0x00, 128);
6781  memset(add_str, 0x00, 128);
6782  memset(tag_str, 0x00, 128);
6783  memset(output, 0x00, 128);
6784 
6785  key_len = unhexify( key_str, "315b206778c28ed0bfdd6e66088a5c39" );
6786  pt_len = unhexify( src_str, "6186f57a85b65f54efbf9974a193012b1396fc0ca887227e1865f1c915ac2af9bbd55969f7de57ce9fb87604cf11c7bc822b542f745be8a101877a810ed72bf4544d0acb91f0f9d3c30b6a18c48b82557433d0db930e03bcecc6fb53530bfd99ee89f9e154aa1a3e2a2c2a7a9e08c9aed1deab7fae8ea5a31158b50bca2f5e79" );
6787  iv_len = unhexify( iv_str, "7ec6f47ec56dda5b52bbdaa6ad2eb6da" );
6788  add_len = unhexify( add_str, "" );
6789  unhexify( tag_str, "930750c53effc7b84aa10b2276" );
6790 
6791  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6792  if( 0 == 0 )
6793  {
6794  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6795 
6796  if( strcmp( "FAIL", "FAIL" ) == 0 )
6797  {
6798  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6799  }
6800  else
6801  {
6802  hexify( dst_str, output, pt_len );
6803 
6804  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
6805  }
6806  }
6807  }
6808  FCT_TEST_END();
6809 
6810 
6811  FCT_TEST_BGN(gcm_nist_validation_aes_12812810240104_2)
6812  {
6813  unsigned char key_str[128];
6814  unsigned char src_str[128];
6815  unsigned char dst_str[257];
6816  unsigned char iv_str[128];
6817  unsigned char add_str[128];
6818  unsigned char tag_str[128];
6819  unsigned char output[128];
6820  gcm_context ctx;
6821  unsigned int key_len;
6822  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
6823  int ret;
6824 
6825  memset(key_str, 0x00, 128);
6826  memset(src_str, 0x00, 128);
6827  memset(dst_str, 0x00, 257);
6828  memset(iv_str, 0x00, 128);
6829  memset(add_str, 0x00, 128);
6830  memset(tag_str, 0x00, 128);
6831  memset(output, 0x00, 128);
6832 
6833  key_len = unhexify( key_str, "e886de1c907c97e7db8ec80a79df90f8" );
6834  pt_len = unhexify( src_str, "c64cc9596d7c738746ab800f688eec190a4c802c55b2528931d74d294496892b81f53d3073d48f9bef1d58ce3be26547474cdda2868abeab71aff566fff613b4e5bfed1be1d2fff35d8ffa33302d3da1c82e421aa3a23848f31e26d90c0cb2ac2ae136ada73404ed3e0e1d3e7cb355a11cd2a4f9393b4d5eac988104fe1cf959" );
6835  iv_len = unhexify( iv_str, "612cacbf33266353d0a29a24532f3c0c" );
6836  add_len = unhexify( add_str, "" );
6837  unhexify( tag_str, "76634e58d8f3a48f15875ac1d6" );
6838 
6839  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6840  if( 0 == 0 )
6841  {
6842  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6843 
6844  if( strcmp( "FAIL", "7001d7395efb432e2804cc65c0ba5d4719ce84177ce46292c4fd62a5596bd2bab1d5c44217ac43235bd94489c43d01618a11f047d2e247062c3b88d6e59adaa1f46514fb33b7843483920bee60a41f3cb312322c305d25251b4704fb66da58637c95a9d539731434f60ef44fe3cd6d37e2c8e7089880a563938dcc98b43f08fd" ) == 0 )
6845  {
6846  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6847  }
6848  else
6849  {
6850  hexify( dst_str, output, pt_len );
6851 
6852  fct_chk( strcmp( (char *) dst_str, "7001d7395efb432e2804cc65c0ba5d4719ce84177ce46292c4fd62a5596bd2bab1d5c44217ac43235bd94489c43d01618a11f047d2e247062c3b88d6e59adaa1f46514fb33b7843483920bee60a41f3cb312322c305d25251b4704fb66da58637c95a9d539731434f60ef44fe3cd6d37e2c8e7089880a563938dcc98b43f08fd" ) == 0 );
6853  }
6854  }
6855  }
6856  FCT_TEST_END();
6857 
6858 
6859  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024096_0)
6860  {
6861  unsigned char key_str[128];
6862  unsigned char src_str[128];
6863  unsigned char dst_str[257];
6864  unsigned char iv_str[128];
6865  unsigned char add_str[128];
6866  unsigned char tag_str[128];
6867  unsigned char output[128];
6868  gcm_context ctx;
6869  unsigned int key_len;
6870  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
6871  int ret;
6872 
6873  memset(key_str, 0x00, 128);
6874  memset(src_str, 0x00, 128);
6875  memset(dst_str, 0x00, 257);
6876  memset(iv_str, 0x00, 128);
6877  memset(add_str, 0x00, 128);
6878  memset(tag_str, 0x00, 128);
6879  memset(output, 0x00, 128);
6880 
6881  key_len = unhexify( key_str, "3b936e09a6477f3bd52030a29df5001d" );
6882  pt_len = unhexify( src_str, "65cf11d1afad19b34f282f98f140315992392f5d4eed4265085b29e1e5553f4783fec681ba2d368486ba6a54c00e71c82c08ca3d097904f021ce4b0acba2d2a7005e28e5f8750ea3d18a4f78363c37583e85104234498942c639a0564b0d80055c21cb7735dd44348298291ab602f345b1d74d624750c0177fbd5cca6f99223b" );
6883  iv_len = unhexify( iv_str, "f93105be83fa5e315d73acfdcf578de7" );
6884  add_len = unhexify( add_str, "" );
6885  unhexify( tag_str, "91b55bb5e3f3f1abcf335db5" );
6886 
6887  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6888  if( 0 == 0 )
6889  {
6890  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6891 
6892  if( strcmp( "FAIL", "FAIL" ) == 0 )
6893  {
6894  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6895  }
6896  else
6897  {
6898  hexify( dst_str, output, pt_len );
6899 
6900  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
6901  }
6902  }
6903  }
6904  FCT_TEST_END();
6905 
6906 
6907  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024096_1)
6908  {
6909  unsigned char key_str[128];
6910  unsigned char src_str[128];
6911  unsigned char dst_str[257];
6912  unsigned char iv_str[128];
6913  unsigned char add_str[128];
6914  unsigned char tag_str[128];
6915  unsigned char output[128];
6916  gcm_context ctx;
6917  unsigned int key_len;
6918  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
6919  int ret;
6920 
6921  memset(key_str, 0x00, 128);
6922  memset(src_str, 0x00, 128);
6923  memset(dst_str, 0x00, 257);
6924  memset(iv_str, 0x00, 128);
6925  memset(add_str, 0x00, 128);
6926  memset(tag_str, 0x00, 128);
6927  memset(output, 0x00, 128);
6928 
6929  key_len = unhexify( key_str, "dc9e2095de7b1b48481b56bf6a3604cd" );
6930  pt_len = unhexify( src_str, "ed61ff94a3f84c72147faefa615e2df00324fb01790cf9764c72c1b8ba47f17866a1fd64ee5c2f53865d1bc24ec93165a6774466a59603199ee476c1f2da7d932c8943d126aa172d532d8475a484d42bb45fcf92766feafd7f3e2e3d42d22f6f84a90e7e688232f799d80cd2cc152ddd21ecfb137701ecafcb2b65abe2e4e6f4" );
6931  iv_len = unhexify( iv_str, "9e5268db19a1b51c0496a160ca76f8f7" );
6932  add_len = unhexify( add_str, "" );
6933  unhexify( tag_str, "0fa9588536fca71bb44260f7" );
6934 
6935  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6936  if( 0 == 0 )
6937  {
6938  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6939 
6940  if( strcmp( "FAIL", "ef562e301fcf923ff1a1acd3aff9b1c963058228655fe8a66cab01396547dbd2aa1f79a22eefc62944b86d1a31ebe2d17130175b8c003d6755b0eb8b79895b0f7f8046c5ae888a067ba17bc8e11a8f6e5023a9cd42f6461966c28e505b371c0f72a2606bff430a58016e99713d25ce11f10391fb4a922e27989422c6a64f9107" ) == 0 )
6941  {
6942  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6943  }
6944  else
6945  {
6946  hexify( dst_str, output, pt_len );
6947 
6948  fct_chk( strcmp( (char *) dst_str, "ef562e301fcf923ff1a1acd3aff9b1c963058228655fe8a66cab01396547dbd2aa1f79a22eefc62944b86d1a31ebe2d17130175b8c003d6755b0eb8b79895b0f7f8046c5ae888a067ba17bc8e11a8f6e5023a9cd42f6461966c28e505b371c0f72a2606bff430a58016e99713d25ce11f10391fb4a922e27989422c6a64f9107" ) == 0 );
6949  }
6950  }
6951  }
6952  FCT_TEST_END();
6953 
6954 
6955  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024096_2)
6956  {
6957  unsigned char key_str[128];
6958  unsigned char src_str[128];
6959  unsigned char dst_str[257];
6960  unsigned char iv_str[128];
6961  unsigned char add_str[128];
6962  unsigned char tag_str[128];
6963  unsigned char output[128];
6964  gcm_context ctx;
6965  unsigned int key_len;
6966  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
6967  int ret;
6968 
6969  memset(key_str, 0x00, 128);
6970  memset(src_str, 0x00, 128);
6971  memset(dst_str, 0x00, 257);
6972  memset(iv_str, 0x00, 128);
6973  memset(add_str, 0x00, 128);
6974  memset(tag_str, 0x00, 128);
6975  memset(output, 0x00, 128);
6976 
6977  key_len = unhexify( key_str, "3f93901fd7cc88db3ba76a158d658c7b" );
6978  pt_len = unhexify( src_str, "16402fded879fcbfe9405902aa63ca2a520889e0045f687455469b7bb867829a01208b8dc5dcc852d8ee478993c30e6d9ec6408773b367821310a0ae171d38d71e06981ff6e845acffbc794142b87c748e12484c0636419d79be3d798cde59e9dae0a4a4a4346596427e6b235ad52e6a1b02d6f4df0c7de35fc390cae36aef14" );
6979  iv_len = unhexify( iv_str, "7e98de461e6d96c0ce6c8d8b3854cf49" );
6980  add_len = unhexify( add_str, "" );
6981  unhexify( tag_str, "86c9a70e4bab304ae46e6542" );
6982 
6983  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
6984  if( 0 == 0 )
6985  {
6986  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
6987 
6988  if( strcmp( "FAIL", "1b4c09569b42c469b3ab6b39312c214502ec09f5fe2fed1d1933d13cdc6a7b77a5d135123fa69d9207d6844b0357b26b7a2f53b33a5cd218dacda87b78b09cf259e48e74076812c432e2d0833fb269721f9347c96e158500f9b2283342a35c8de0a022edce711118d72d8fbaa354bfb0ffee465844ef2d37e24ec2cea8556648" ) == 0 )
6989  {
6990  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
6991  }
6992  else
6993  {
6994  hexify( dst_str, output, pt_len );
6995 
6996  fct_chk( strcmp( (char *) dst_str, "1b4c09569b42c469b3ab6b39312c214502ec09f5fe2fed1d1933d13cdc6a7b77a5d135123fa69d9207d6844b0357b26b7a2f53b33a5cd218dacda87b78b09cf259e48e74076812c432e2d0833fb269721f9347c96e158500f9b2283342a35c8de0a022edce711118d72d8fbaa354bfb0ffee465844ef2d37e24ec2cea8556648" ) == 0 );
6997  }
6998  }
6999  }
7000  FCT_TEST_END();
7001 
7002 
7003  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024064_0)
7004  {
7005  unsigned char key_str[128];
7006  unsigned char src_str[128];
7007  unsigned char dst_str[257];
7008  unsigned char iv_str[128];
7009  unsigned char add_str[128];
7010  unsigned char tag_str[128];
7011  unsigned char output[128];
7012  gcm_context ctx;
7013  unsigned int key_len;
7014  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
7015  int ret;
7016 
7017  memset(key_str, 0x00, 128);
7018  memset(src_str, 0x00, 128);
7019  memset(dst_str, 0x00, 257);
7020  memset(iv_str, 0x00, 128);
7021  memset(add_str, 0x00, 128);
7022  memset(tag_str, 0x00, 128);
7023  memset(output, 0x00, 128);
7024 
7025  key_len = unhexify( key_str, "42289f3d3cd5838e250ef54b128e60d1" );
7026  pt_len = unhexify( src_str, "3edae1d554b67d2036f5fdbdb2945cc112f100adc1b47009c2e23f6a2eaee78d1f39ce8a98f715853cc29fc793fb6981ec3036834188dea7d668185ccc8642071b15de1332f6a59c8a9b4399733eb4b3d8f224af57ba6b4a8e64494bb6630b9d28e7ec3349064350febcef6a3ad1d6cca1b1da74f3d2921c2b28a2dd399c3416" );
7027  iv_len = unhexify( iv_str, "e557389a216ad724aafdab0180e1892e" );
7028  add_len = unhexify( add_str, "" );
7029  unhexify( tag_str, "6f78bc809f31393e" );
7030 
7031  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7032  if( 0 == 0 )
7033  {
7034  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7035 
7036  if( strcmp( "FAIL", "25c476659cc7b343a69088baf868a811ba37daca85c4093105bf98235a90aeca015ab034da008af0982f9b2e80df804c186a9b2e97f74cffd70ebb7771d874fcaf12f6d01c44a8b0ec2898cf4493cf09a16a88a65cd77909bbf0430c9603869bd5f20d56cb51d8a3f0a032fc30d925c96599d296b1ec41c2912bda426adea4fb" ) == 0 )
7037  {
7038  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7039  }
7040  else
7041  {
7042  hexify( dst_str, output, pt_len );
7043 
7044  fct_chk( strcmp( (char *) dst_str, "25c476659cc7b343a69088baf868a811ba37daca85c4093105bf98235a90aeca015ab034da008af0982f9b2e80df804c186a9b2e97f74cffd70ebb7771d874fcaf12f6d01c44a8b0ec2898cf4493cf09a16a88a65cd77909bbf0430c9603869bd5f20d56cb51d8a3f0a032fc30d925c96599d296b1ec41c2912bda426adea4fb" ) == 0 );
7045  }
7046  }
7047  }
7048  FCT_TEST_END();
7049 
7050 
7051  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024064_1)
7052  {
7053  unsigned char key_str[128];
7054  unsigned char src_str[128];
7055  unsigned char dst_str[257];
7056  unsigned char iv_str[128];
7057  unsigned char add_str[128];
7058  unsigned char tag_str[128];
7059  unsigned char output[128];
7060  gcm_context ctx;
7061  unsigned int key_len;
7062  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
7063  int ret;
7064 
7065  memset(key_str, 0x00, 128);
7066  memset(src_str, 0x00, 128);
7067  memset(dst_str, 0x00, 257);
7068  memset(iv_str, 0x00, 128);
7069  memset(add_str, 0x00, 128);
7070  memset(tag_str, 0x00, 128);
7071  memset(output, 0x00, 128);
7072 
7073  key_len = unhexify( key_str, "3d772eabb7f19475665ca2a7e693bcfc" );
7074  pt_len = unhexify( src_str, "e9fc4d86f5b857fa6057b73f967351e06f87288c40a95b9e378c84f1a4c0f4b80ed0a0b44ff90a8973be4199c0c4006fc4f5ea19d5f1fe8b9c8c01f4675ab85afab0592bb3daba36bb4fc7ed9eea867e9d8cc50c19fb62a5a57956e9efacebac5e9f849649d35a329bd68de97bb6e5ff7bef477a86765c2c9ec15e24cbba5c6e" );
7075  iv_len = unhexify( iv_str, "0747cbb486a013453fde1ca6abb11dbe" );
7076  add_len = unhexify( add_str, "" );
7077  unhexify( tag_str, "8e761ffaea68f967" );
7078 
7079  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7080  if( 0 == 0 )
7081  {
7082  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7083 
7084  if( strcmp( "FAIL", "FAIL" ) == 0 )
7085  {
7086  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7087  }
7088  else
7089  {
7090  hexify( dst_str, output, pt_len );
7091 
7092  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
7093  }
7094  }
7095  }
7096  FCT_TEST_END();
7097 
7098 
7099  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024064_2)
7100  {
7101  unsigned char key_str[128];
7102  unsigned char src_str[128];
7103  unsigned char dst_str[257];
7104  unsigned char iv_str[128];
7105  unsigned char add_str[128];
7106  unsigned char tag_str[128];
7107  unsigned char output[128];
7108  gcm_context ctx;
7109  unsigned int key_len;
7110  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
7111  int ret;
7112 
7113  memset(key_str, 0x00, 128);
7114  memset(src_str, 0x00, 128);
7115  memset(dst_str, 0x00, 257);
7116  memset(iv_str, 0x00, 128);
7117  memset(add_str, 0x00, 128);
7118  memset(tag_str, 0x00, 128);
7119  memset(output, 0x00, 128);
7120 
7121  key_len = unhexify( key_str, "fb7fd753ee6eaaf283a42a121dab4e43" );
7122  pt_len = unhexify( src_str, "fd5cecb2c0287cb8229e97d9cc4b9885f428710528884ce663ed1728cd44cb2df93e56ef17ace0678d1e341366c652f4ba7ee45797d39be4a05c1151e5cde499e13e5d45549b5d95a174d03616d06ef96e9d7b2b6bb0d79a726b253dd64223a5f09611671b234ccf9b383952f8888814b2c167e774cfbf54e9c6b99a753f4fa9" );
7123  iv_len = unhexify( iv_str, "8164929fb54485377ecccc9b9621af5e" );
7124  add_len = unhexify( add_str, "" );
7125  unhexify( tag_str, "40a2fa7f4370afb2" );
7126 
7127  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7128  if( 0 == 0 )
7129  {
7130  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7131 
7132  if( strcmp( "FAIL", "6208d068be60f7b04b80fc611062e6caaef9a5cf59f850d174b7446c78c039ea9aefe4885e19c2b33911d32ce1fe3c48ddffa4b03e450fd35da03f40c4e7c5bb3b1c3f3049dbfad3ac81ca1b79cafbaa172f4900e3829d38edea3b64000f93924a801259bc4b2523445c64bc23bfee190b952468507fa4baf6dc2bec66fcf0d8" ) == 0 )
7133  {
7134  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7135  }
7136  else
7137  {
7138  hexify( dst_str, output, pt_len );
7139 
7140  fct_chk( strcmp( (char *) dst_str, "6208d068be60f7b04b80fc611062e6caaef9a5cf59f850d174b7446c78c039ea9aefe4885e19c2b33911d32ce1fe3c48ddffa4b03e450fd35da03f40c4e7c5bb3b1c3f3049dbfad3ac81ca1b79cafbaa172f4900e3829d38edea3b64000f93924a801259bc4b2523445c64bc23bfee190b952468507fa4baf6dc2bec66fcf0d8" ) == 0 );
7141  }
7142  }
7143  }
7144  FCT_TEST_END();
7145 
7146 
7147  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024032_0)
7148  {
7149  unsigned char key_str[128];
7150  unsigned char src_str[128];
7151  unsigned char dst_str[257];
7152  unsigned char iv_str[128];
7153  unsigned char add_str[128];
7154  unsigned char tag_str[128];
7155  unsigned char output[128];
7156  gcm_context ctx;
7157  unsigned int key_len;
7158  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
7159  int ret;
7160 
7161  memset(key_str, 0x00, 128);
7162  memset(src_str, 0x00, 128);
7163  memset(dst_str, 0x00, 257);
7164  memset(iv_str, 0x00, 128);
7165  memset(add_str, 0x00, 128);
7166  memset(tag_str, 0x00, 128);
7167  memset(output, 0x00, 128);
7168 
7169  key_len = unhexify( key_str, "30d757fd73a0fd5fa49159ad0653296d" );
7170  pt_len = unhexify( src_str, "17d485b258f80d8924e35291118cfdcffd86c47851b65f0b06a7c1f5202de82f3f460fc61b1aa38fdba7c8ded375c92cf005afe63e59d362c0960044af39241b81ca24e85c5faa43903229355b7313fee21b992ef3931d9d2407b32b3cf72dd7acbc7948395eb513cb2fd428b215ba2bd1e29c62f45d0ce231884f62480c6d8f" );
7171  iv_len = unhexify( iv_str, "b35b8df0aebd0608517f2830e0e70cd0" );
7172  add_len = unhexify( add_str, "" );
7173  unhexify( tag_str, "954c0e99" );
7174 
7175  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7176  if( 0 == 0 )
7177  {
7178  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7179 
7180  if( strcmp( "FAIL", "022618d2598f79104e918a09c937a82b3db59243b5e13de731fcb912e4366105797ce47f6dce7f08073f2f41e5c15fd6b1ec4b5861469a4880c3b0bd769b78c696ff29c28c9349d5a46a6e5ad9211bd4b708a8c0b6928ebbb0dac1c0a5f5ce6b05de6a50073128566a23f09cc1b826aa5803f9f750aa4debf59f24ae9f98c9b5" ) == 0 )
7181  {
7182  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7183  }
7184  else
7185  {
7186  hexify( dst_str, output, pt_len );
7187 
7188  fct_chk( strcmp( (char *) dst_str, "022618d2598f79104e918a09c937a82b3db59243b5e13de731fcb912e4366105797ce47f6dce7f08073f2f41e5c15fd6b1ec4b5861469a4880c3b0bd769b78c696ff29c28c9349d5a46a6e5ad9211bd4b708a8c0b6928ebbb0dac1c0a5f5ce6b05de6a50073128566a23f09cc1b826aa5803f9f750aa4debf59f24ae9f98c9b5" ) == 0 );
7189  }
7190  }
7191  }
7192  FCT_TEST_END();
7193 
7194 
7195  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024032_1)
7196  {
7197  unsigned char key_str[128];
7198  unsigned char src_str[128];
7199  unsigned char dst_str[257];
7200  unsigned char iv_str[128];
7201  unsigned char add_str[128];
7202  unsigned char tag_str[128];
7203  unsigned char output[128];
7204  gcm_context ctx;
7205  unsigned int key_len;
7206  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
7207  int ret;
7208 
7209  memset(key_str, 0x00, 128);
7210  memset(src_str, 0x00, 128);
7211  memset(dst_str, 0x00, 257);
7212  memset(iv_str, 0x00, 128);
7213  memset(add_str, 0x00, 128);
7214  memset(tag_str, 0x00, 128);
7215  memset(output, 0x00, 128);
7216 
7217  key_len = unhexify( key_str, "d9d3cfd5900de5d5e2109e7721cfeef6" );
7218  pt_len = unhexify( src_str, "e4243cc37cc32dfcedf9bb76890e706af6ab1e06b290b8ccfe2a55e5dabe68cb390f7636dc9676b431d4dc8ad3f6d989e510194294ab7ab0556789046743cf374d8b6462f5f95a17f3f44337d6c69ee47b0e1ad7e5ce6f9b224c54099a104e70d2d06af869b921ea47febe08f90c591ed49c1f12003afceabd2c7bba458a0111" );
7219  iv_len = unhexify( iv_str, "b4b9dfb013de6f7c44779e5a9daaf5e5" );
7220  add_len = unhexify( add_str, "" );
7221  unhexify( tag_str, "2b81e8ce" );
7222 
7223  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7224  if( 0 == 0 )
7225  {
7226  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7227 
7228  if( strcmp( "FAIL", "FAIL" ) == 0 )
7229  {
7230  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7231  }
7232  else
7233  {
7234  hexify( dst_str, output, pt_len );
7235 
7236  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
7237  }
7238  }
7239  }
7240  FCT_TEST_END();
7241 
7242 
7243  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024032_2)
7244  {
7245  unsigned char key_str[128];
7246  unsigned char src_str[128];
7247  unsigned char dst_str[257];
7248  unsigned char iv_str[128];
7249  unsigned char add_str[128];
7250  unsigned char tag_str[128];
7251  unsigned char output[128];
7252  gcm_context ctx;
7253  unsigned int key_len;
7254  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
7255  int ret;
7256 
7257  memset(key_str, 0x00, 128);
7258  memset(src_str, 0x00, 128);
7259  memset(dst_str, 0x00, 257);
7260  memset(iv_str, 0x00, 128);
7261  memset(add_str, 0x00, 128);
7262  memset(tag_str, 0x00, 128);
7263  memset(output, 0x00, 128);
7264 
7265  key_len = unhexify( key_str, "68dc138f19354d73eaa1cf0e79231d74" );
7266  pt_len = unhexify( src_str, "ce345567a76bc30d8b4fd2239788221cfa75e1a310aeeeb8c355f8eea57d80967f3047fbd4e6173fac5caeb22151fa607065953c4c35e0537b9e3788cc80de9eedf2a340698bde99a6a1bdc81265319da3e52f7a53883b7f21749237fcfd3cd4f149bb2be7a4ddd9ef0544cfe0789040d1dc951b6447304942f03ab0beae8866" );
7267  iv_len = unhexify( iv_str, "e7147749560f491420a2d893c075bb76" );
7268  add_len = unhexify( add_str, "" );
7269  unhexify( tag_str, "70a83f6f" );
7270 
7271  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7272  if( 0 == 0 )
7273  {
7274  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7275 
7276  if( strcmp( "FAIL", "64b021612c78b3e192e8349d48b77d02927e7fd70c7160d37cb8ef472f6bcd9df9d93431627c1c80875e208724ae05f94fdd2e005e9707b78a1bf3bbca7beec4b03ddd4d9de6235ffd6d84a8b9a1842e104c1e22df4566f6c4d3d4e3d96a56b9b8a5cdce9da70aa236109b289266036f285564060b204dfd7ac915eea0dd0b1e" ) == 0 )
7277  {
7278  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7279  }
7280  else
7281  {
7282  hexify( dst_str, output, pt_len );
7283 
7284  fct_chk( strcmp( (char *) dst_str, "64b021612c78b3e192e8349d48b77d02927e7fd70c7160d37cb8ef472f6bcd9df9d93431627c1c80875e208724ae05f94fdd2e005e9707b78a1bf3bbca7beec4b03ddd4d9de6235ffd6d84a8b9a1842e104c1e22df4566f6c4d3d4e3d96a56b9b8a5cdce9da70aa236109b289266036f285564060b204dfd7ac915eea0dd0b1e" ) == 0 );
7285  }
7286  }
7287  }
7288  FCT_TEST_END();
7289 
7290 
7291  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024128_0)
7292  {
7293  unsigned char key_str[128];
7294  unsigned char src_str[128];
7295  unsigned char dst_str[257];
7296  unsigned char iv_str[128];
7297  unsigned char add_str[128];
7298  unsigned char tag_str[128];
7299  unsigned char output[128];
7300  gcm_context ctx;
7301  unsigned int key_len;
7302  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
7303  int ret;
7304 
7305  memset(key_str, 0x00, 128);
7306  memset(src_str, 0x00, 128);
7307  memset(dst_str, 0x00, 257);
7308  memset(iv_str, 0x00, 128);
7309  memset(add_str, 0x00, 128);
7310  memset(tag_str, 0x00, 128);
7311  memset(output, 0x00, 128);
7312 
7313  key_len = unhexify( key_str, "7362c86344e0aefb0cf0d04768f9c05d" );
7314  pt_len = unhexify( src_str, "8baffc7836004deb87c0111d47c182512bf861874021ddfcd559acf2c4a51cf5bc4bfdee2d039b9c005b6af95a2607643dcf4d9cd9d62412f709334556db22fc91d7b40438505d6806ccb2f2c21ae731bc1f1c825d28a71ab27095a39985e96ccd07cfb2e75243ccafd474494a2338c324ef533ca5f17d2ac1b1883140342ced" );
7315  iv_len = unhexify( iv_str, "7e8d12c2f0dcf4f792247134234ac94b" );
7316  add_len = unhexify( add_str, "86d2b5debc3b10495da353d6821f6cad380776d805bd8660b08dcdb1acd87026e4f344b547a4db47b5f44cded314bec4ce9a417ce40a2acd5a21460c42dfcd27483abf3f38dd8cc5fa523b6768a26513df5896435baa97781cff1966e2e3d6ec6d0a9cdc013de5a50e4d46831667055bad04f784024a82f9cd087ae4cd37dd64" );
7317  unhexify( tag_str, "9594da428fd8c1b13ecb23afa2c1af2e" );
7318 
7319  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7320  if( 0 == 0 )
7321  {
7322  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7323 
7324  if( strcmp( "FAIL", "e2c424f42aedd56f0e17a39d43ad19c8e2731efc7a25f077aef51d55280b10e667e338bd981b82a975ef62bf53bc52496b6995d33c90c7ae14767c126826e3f32bd23f444ddcfd7a0dd323b0ae2c22defad04ce63892b45c176bd0b86f5fa057a3dc371359744cb80bbfb4a195755136a0ea90b4044a45bc1b069f3cb3695c04" ) == 0 )
7325  {
7326  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7327  }
7328  else
7329  {
7330  hexify( dst_str, output, pt_len );
7331 
7332  fct_chk( strcmp( (char *) dst_str, "e2c424f42aedd56f0e17a39d43ad19c8e2731efc7a25f077aef51d55280b10e667e338bd981b82a975ef62bf53bc52496b6995d33c90c7ae14767c126826e3f32bd23f444ddcfd7a0dd323b0ae2c22defad04ce63892b45c176bd0b86f5fa057a3dc371359744cb80bbfb4a195755136a0ea90b4044a45bc1b069f3cb3695c04" ) == 0 );
7333  }
7334  }
7335  }
7336  FCT_TEST_END();
7337 
7338 
7339  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024128_1)
7340  {
7341  unsigned char key_str[128];
7342  unsigned char src_str[128];
7343  unsigned char dst_str[257];
7344  unsigned char iv_str[128];
7345  unsigned char add_str[128];
7346  unsigned char tag_str[128];
7347  unsigned char output[128];
7348  gcm_context ctx;
7349  unsigned int key_len;
7350  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
7351  int ret;
7352 
7353  memset(key_str, 0x00, 128);
7354  memset(src_str, 0x00, 128);
7355  memset(dst_str, 0x00, 257);
7356  memset(iv_str, 0x00, 128);
7357  memset(add_str, 0x00, 128);
7358  memset(tag_str, 0x00, 128);
7359  memset(output, 0x00, 128);
7360 
7361  key_len = unhexify( key_str, "58748bb204ccb7bdafdbf739b6c19a3e" );
7362  pt_len = unhexify( src_str, "b72902c9ebb72a86be539b19a52fd9af00aa4de081d90c0d8ad580ebb5900177a036f40a1e9b43e3a07d715466526d6d7544e5a5551805b62463f956cd519fc99182c2d54bd62fc7ffc6e5ebf1503859b706da11a1b6c707a67a70789dbfc10ef726bd360f9f2347326e068e757c8443ddc9308a171e682359ae1bfe87194ab5" );
7363  iv_len = unhexify( iv_str, "93ac298c73c88e127a4d9dd81bf24e3d" );
7364  add_len = unhexify( add_str, "8f168fc4d1da13bdbefae3f9d6ac1d8cb19fcec1f43f727951af0a466d8826649a46c3cb50c045ea83849fce0eedbc042a1a435e6d9d59017997a2d5459b940078b8a7f3b6b0ff279ff8c560248296a17240ff1b0643d1f436b6e3f2079363fc49fb45f410debbdde083b92057916368cb807d603cb82e2c0dc01658bff7f1ab" );
7365  unhexify( tag_str, "efba4589d4a03555766bbc3b421dd60f" );
7366 
7367  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7368  if( 0 == 0 )
7369  {
7370  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7371 
7372  if( strcmp( "FAIL", "d5c97a659f016904ff76286f810e8e92da6f8db2c63d8a42e617760780637e32105503440cdf04d1fe67813312f1479fda8d746c8b0b080591eba83850382f600e9d8680516c6579669f0b3d0a30323510f9de1c92512790b8347751994d022156cae64da0808a649d163a0e99e869fdf224b7c1a6a8fbc613d5917eca8ee08c" ) == 0 )
7373  {
7374  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7375  }
7376  else
7377  {
7378  hexify( dst_str, output, pt_len );
7379 
7380  fct_chk( strcmp( (char *) dst_str, "d5c97a659f016904ff76286f810e8e92da6f8db2c63d8a42e617760780637e32105503440cdf04d1fe67813312f1479fda8d746c8b0b080591eba83850382f600e9d8680516c6579669f0b3d0a30323510f9de1c92512790b8347751994d022156cae64da0808a649d163a0e99e869fdf224b7c1a6a8fbc613d5917eca8ee08c" ) == 0 );
7381  }
7382  }
7383  }
7384  FCT_TEST_END();
7385 
7386 
7387  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024128_2)
7388  {
7389  unsigned char key_str[128];
7390  unsigned char src_str[128];
7391  unsigned char dst_str[257];
7392  unsigned char iv_str[128];
7393  unsigned char add_str[128];
7394  unsigned char tag_str[128];
7395  unsigned char output[128];
7396  gcm_context ctx;
7397  unsigned int key_len;
7398  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
7399  int ret;
7400 
7401  memset(key_str, 0x00, 128);
7402  memset(src_str, 0x00, 128);
7403  memset(dst_str, 0x00, 257);
7404  memset(iv_str, 0x00, 128);
7405  memset(add_str, 0x00, 128);
7406  memset(tag_str, 0x00, 128);
7407  memset(output, 0x00, 128);
7408 
7409  key_len = unhexify( key_str, "6cc13cbd62428bb8658dd3954fe9181f" );
7410  pt_len = unhexify( src_str, "2c9ec982d1cfb644ddbc53c0759b10493206d5186affc6882fbb2ba3aa430f9bae1209db2d78dcc125f3c909a54dd84fdff96c71e678216a58390ef4308bdd90f94f7109c4edefa76a74fda64b201b7a435bbabc27298f3eaa4c2d1393bd584f811fff52638f6ad2f6d86a8c3c9c030d9d4264c8c079592a36178d25991cff09" );
7411  iv_len = unhexify( iv_str, "86740da7ce4efbed70af55e1d6c10fdf" );
7412  add_len = unhexify( add_str, "be561ac15e3cfda624b422af97c26719c140bb50e4a993d636efe9c7f1963fb9047a0762169b571a698ff310bc417e34d4039b7562a95af710ccc1b197964a376c986fd2ed8ac4b0c7b4e843c37a41366f2f483c821a1823f317416c7e4f32eed9b9dc2ae1a2f3ed32c4b3187358a2329aa42191b7c2fe87b6e27ff20303cb29" );
7413  unhexify( tag_str, "76b990a1e010e5f088f6ae90bec40b32" );
7414 
7415  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7416  if( 0 == 0 )
7417  {
7418  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7419 
7420  if( strcmp( "FAIL", "0b9a5f5d2e6852b75b9cf26c1b310b2200e56dafcf3c941478862cdf9737ac8e2cb9b38d41bd4a1872ea1b4cfd51a1a0b9b743aca439eefa10de8459a0a7a221c5429b3dee393f17031ca6c399df8e05657c3db55be9c9dd29e690042a4ed8db732efce7c58d6b20a2a0f7c79e42e5ada43b87ab00f481c20cac1b35514dcdc9" ) == 0 )
7421  {
7422  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7423  }
7424  else
7425  {
7426  hexify( dst_str, output, pt_len );
7427 
7428  fct_chk( strcmp( (char *) dst_str, "0b9a5f5d2e6852b75b9cf26c1b310b2200e56dafcf3c941478862cdf9737ac8e2cb9b38d41bd4a1872ea1b4cfd51a1a0b9b743aca439eefa10de8459a0a7a221c5429b3dee393f17031ca6c399df8e05657c3db55be9c9dd29e690042a4ed8db732efce7c58d6b20a2a0f7c79e42e5ada43b87ab00f481c20cac1b35514dcdc9" ) == 0 );
7429  }
7430  }
7431  }
7432  FCT_TEST_END();
7433 
7434 
7435  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024120_0)
7436  {
7437  unsigned char key_str[128];
7438  unsigned char src_str[128];
7439  unsigned char dst_str[257];
7440  unsigned char iv_str[128];
7441  unsigned char add_str[128];
7442  unsigned char tag_str[128];
7443  unsigned char output[128];
7444  gcm_context ctx;
7445  unsigned int key_len;
7446  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
7447  int ret;
7448 
7449  memset(key_str, 0x00, 128);
7450  memset(src_str, 0x00, 128);
7451  memset(dst_str, 0x00, 257);
7452  memset(iv_str, 0x00, 128);
7453  memset(add_str, 0x00, 128);
7454  memset(tag_str, 0x00, 128);
7455  memset(output, 0x00, 128);
7456 
7457  key_len = unhexify( key_str, "286d3f5080cfe88538571188fbeb2dd5" );
7458  pt_len = unhexify( src_str, "55135928997711360622eda1820c815aa22115204b1e9bb567e231ac6ea2594b4d652627b6816bdc6c40a4411fd6b12fab9a1f169d81c476dbf77151bff13f98ca0d1dc0a68ea681652be089fadbc66c604284eebfc8ce4cf10f4ca6bda0e0f6634023db6e3f0f1de626c3249a28a642ecc9ec5ff401e941fa8a3c691566c0ae" );
7459  iv_len = unhexify( iv_str, "da6140bd4dc6456ddab19069e86efb35" );
7460  add_len = unhexify( add_str, "5d350a04562a605e9082ebd8faec6c27e561425849e7f0f05f5049859c2c1bd2c4682ebf9773fab6177d2601fd5a086cefc3adef5a2f8f6b5dc9e649e98dd0a3d1a2524419f01305bd0fcfff52d84a20d1b14dea2138dcc54eea2bf263c6fe27c3e7255f1f359d0d00fb1b350d7a04965af30027632520197e85eb41de6bb286" );
7461  unhexify( tag_str, "d90d34094d740214dd3de685010ce3" );
7462 
7463  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7464  if( 0 == 0 )
7465  {
7466  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7467 
7468  if( strcmp( "FAIL", "FAIL" ) == 0 )
7469  {
7470  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7471  }
7472  else
7473  {
7474  hexify( dst_str, output, pt_len );
7475 
7476  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
7477  }
7478  }
7479  }
7480  FCT_TEST_END();
7481 
7482 
7483  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024120_1)
7484  {
7485  unsigned char key_str[128];
7486  unsigned char src_str[128];
7487  unsigned char dst_str[257];
7488  unsigned char iv_str[128];
7489  unsigned char add_str[128];
7490  unsigned char tag_str[128];
7491  unsigned char output[128];
7492  gcm_context ctx;
7493  unsigned int key_len;
7494  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
7495  int ret;
7496 
7497  memset(key_str, 0x00, 128);
7498  memset(src_str, 0x00, 128);
7499  memset(dst_str, 0x00, 257);
7500  memset(iv_str, 0x00, 128);
7501  memset(add_str, 0x00, 128);
7502  memset(tag_str, 0x00, 128);
7503  memset(output, 0x00, 128);
7504 
7505  key_len = unhexify( key_str, "726ae113a096769b657f973ea6d2d5dd" );
7506  pt_len = unhexify( src_str, "90636012ba8c51d16f8f6df3d3bcabc3f09aeffbe2a762f62e677913188045b861b2e7d9a7bd93dcee46e9e4832e497a6f79db52b4e45c8dab20fa568ff9c4ace55be3216f514a3284768a25d86b1c7da5377622f3e90ed4c7bd4571715af4d0a2ab5181d0475f699202e4406bb9cfdbd4fa7f22d0dd744d36b3223134658496" );
7507  iv_len = unhexify( iv_str, "2f9900226c97585d200dd20a279c154a" );
7508  add_len = unhexify( add_str, "761663c3fcbf1db12bc25546b2425b8229b3153e75f79fa63958819caee3febff74603d99264b5a82ef5980439bef89301ae3206a1d01a3bbd7a6c99d27d1e934cc725daeb483f826c2c9d788fd1f67a627864cf8b5f94df777bb59ef90cb6781a2000e6f0baa4f1ea4754b47bb7cbd2699f83634e4d8ab16b325b2c49f13499" );
7509  unhexify( tag_str, "d095bfb8990d4fd64752ee24f3de1e" );
7510 
7511  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7512  if( 0 == 0 )
7513  {
7514  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7515 
7516  if( strcmp( "FAIL", "9f7759c6d24fd9aa0df02a7c0cc5f17e61622c63195f85dfafa5d820d3ad218c7288ec017821100f1fade10f9bb447a4a01e3698b045548c7619a08f2304e2818a9bf55e70b40f8b994b7dcf0cb243848cf3f6fdfec3ebbb147d01df84a3ec62cd8fa5d78ad9f2f28cd288a35eb49a5172339e9872e8e7e3350b0d69f59acd07" ) == 0 )
7517  {
7518  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7519  }
7520  else
7521  {
7522  hexify( dst_str, output, pt_len );
7523 
7524  fct_chk( strcmp( (char *) dst_str, "9f7759c6d24fd9aa0df02a7c0cc5f17e61622c63195f85dfafa5d820d3ad218c7288ec017821100f1fade10f9bb447a4a01e3698b045548c7619a08f2304e2818a9bf55e70b40f8b994b7dcf0cb243848cf3f6fdfec3ebbb147d01df84a3ec62cd8fa5d78ad9f2f28cd288a35eb49a5172339e9872e8e7e3350b0d69f59acd07" ) == 0 );
7525  }
7526  }
7527  }
7528  FCT_TEST_END();
7529 
7530 
7531  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024120_2)
7532  {
7533  unsigned char key_str[128];
7534  unsigned char src_str[128];
7535  unsigned char dst_str[257];
7536  unsigned char iv_str[128];
7537  unsigned char add_str[128];
7538  unsigned char tag_str[128];
7539  unsigned char output[128];
7540  gcm_context ctx;
7541  unsigned int key_len;
7542  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
7543  int ret;
7544 
7545  memset(key_str, 0x00, 128);
7546  memset(src_str, 0x00, 128);
7547  memset(dst_str, 0x00, 257);
7548  memset(iv_str, 0x00, 128);
7549  memset(add_str, 0x00, 128);
7550  memset(tag_str, 0x00, 128);
7551  memset(output, 0x00, 128);
7552 
7553  key_len = unhexify( key_str, "73a9eeda721c6f292e6b399e2647f8a6" );
7554  pt_len = unhexify( src_str, "215fc7e52abe4c751ca2f7f9a5cbde9ab8b44b8d4054bb62dcea6df5b936145ca6ec83a2b78b070638fd6e5ea3bad5d0caf1b8f755f391c3e0962a92337e3eba575585eb83680075fc818860388c587746af78d5fc75ccd0a63f1612abb1ba0f04a2228ca27fbddba4878f9b2683683f516b6d6fe4f6622e603bd3c5ad45e332" );
7555  iv_len = unhexify( iv_str, "c1e80eb723960049cc4448b66433f1cf" );
7556  add_len = unhexify( add_str, "fb2a0b1f817404e74aee0a6ec8f2cd86f0c9114ed367b2690c44ad80f9d3377d7fd5066beaf1daa739d27ed3fba98379188016b1fe901204a174f9ffca370c181aece5e5d40939a0d460913b40b895e78a3b80ddf3d613c05e4e27bfd161ea2ef42271a2679f2cdca5b728ffb2319781c946a4f3ecacf486b754b30bb04ea60b" );
7557  unhexify( tag_str, "e08161262234d0d5be22f09e5646bf" );
7558 
7559  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7560  if( 0 == 0 )
7561  {
7562  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7563 
7564  if( strcmp( "FAIL", "b5e286183f16dd9403bec6786bd4836cc6add47947ef111fb1d5503c18c333c8fe60959502f58390d0e0f69fbe5fee13c72aed65fe6e32f6ea45877fe44f8a556aa5157b112e572197c1c350b7943c6cf2e9146018599524d27599f09c86027f2c5927e4a20c63833870e8369baa36ecc07cdb3ced520b5ae46869ff357ca089" ) == 0 )
7565  {
7566  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7567  }
7568  else
7569  {
7570  hexify( dst_str, output, pt_len );
7571 
7572  fct_chk( strcmp( (char *) dst_str, "b5e286183f16dd9403bec6786bd4836cc6add47947ef111fb1d5503c18c333c8fe60959502f58390d0e0f69fbe5fee13c72aed65fe6e32f6ea45877fe44f8a556aa5157b112e572197c1c350b7943c6cf2e9146018599524d27599f09c86027f2c5927e4a20c63833870e8369baa36ecc07cdb3ced520b5ae46869ff357ca089" ) == 0 );
7573  }
7574  }
7575  }
7576  FCT_TEST_END();
7577 
7578 
7579  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024112_0)
7580  {
7581  unsigned char key_str[128];
7582  unsigned char src_str[128];
7583  unsigned char dst_str[257];
7584  unsigned char iv_str[128];
7585  unsigned char add_str[128];
7586  unsigned char tag_str[128];
7587  unsigned char output[128];
7588  gcm_context ctx;
7589  unsigned int key_len;
7590  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
7591  int ret;
7592 
7593  memset(key_str, 0x00, 128);
7594  memset(src_str, 0x00, 128);
7595  memset(dst_str, 0x00, 257);
7596  memset(iv_str, 0x00, 128);
7597  memset(add_str, 0x00, 128);
7598  memset(tag_str, 0x00, 128);
7599  memset(output, 0x00, 128);
7600 
7601  key_len = unhexify( key_str, "90dbda7397d8fc46215a1218a6ffd0d8" );
7602  pt_len = unhexify( src_str, "4f82a1eca6c9184240f50f7e0cfec07ec772cad5276d93043c462d8364addd9a652eed385ccc6b0faa6ca679ab3a4c3d0be6a759425fd38316ee6a1b1b0c52c1bb3b57a9bd7c8a3be95c82f37800c2e3b42dde031851937398811f8f8dc2a15bfd2d6be99a572d56f536e62bc5b041d3944da666081cd755ec347f464214bf33" );
7603  iv_len = unhexify( iv_str, "7be477d14df5dc15877ae537b62e1a56" );
7604  add_len = unhexify( add_str, "7358ddf1310a58871a2f76705f1cf64223c015c4d1574104d2e38783bb866205042f05c86e76c47a2516ce284911f1d2cbee079982dd77167e328b8324eec47c9244cc5668cf908c679bb586d4dd32c6c99ed99a6b571cf18b00689463e7a88cea6ea32d288301a10a9139ed6092ffe298e25b8cfb6b4be8217f16076dcd0a90" );
7605  unhexify( tag_str, "776d871944159c51b2f5ec1980a6" );
7606 
7607  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7608  if( 0 == 0 )
7609  {
7610  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7611 
7612  if( strcmp( "FAIL", "FAIL" ) == 0 )
7613  {
7614  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7615  }
7616  else
7617  {
7618  hexify( dst_str, output, pt_len );
7619 
7620  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
7621  }
7622  }
7623  }
7624  FCT_TEST_END();
7625 
7626 
7627  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024112_1)
7628  {
7629  unsigned char key_str[128];
7630  unsigned char src_str[128];
7631  unsigned char dst_str[257];
7632  unsigned char iv_str[128];
7633  unsigned char add_str[128];
7634  unsigned char tag_str[128];
7635  unsigned char output[128];
7636  gcm_context ctx;
7637  unsigned int key_len;
7638  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
7639  int ret;
7640 
7641  memset(key_str, 0x00, 128);
7642  memset(src_str, 0x00, 128);
7643  memset(dst_str, 0x00, 257);
7644  memset(iv_str, 0x00, 128);
7645  memset(add_str, 0x00, 128);
7646  memset(tag_str, 0x00, 128);
7647  memset(output, 0x00, 128);
7648 
7649  key_len = unhexify( key_str, "0c85174d428fc1c7c89ca5d1b8aaba25" );
7650  pt_len = unhexify( src_str, "3735cbfb8000260021d1938d2a18e7737f378ecddb11a46ce387bf04e20bbfcc902457637fd152ab87017185601f32a7f906057123b6c2da31a1069c93e3cacc59a359aebd3e31b302e1a1f7d5d8f1b2917a8fe79181fa633b925ce03a1198dac48f4c959076b55bc6b3d50188af2c6aa33d83698aa8db22649f39825ba54775" );
7651  iv_len = unhexify( iv_str, "b3c9dfa4c55388a128fbf62aa5927361" );
7652  add_len = unhexify( add_str, "3f552d45b61cf05ae2aa92668e89f3338a15ec7c5b7113b6571cfcd9e4c4a962043ccd9323f828dd645e8a91b007ce2112b7f978ad22ee9821698a4f2559d987ae4421452ad2e8d180953297156426d4540aff2104d8637b56b034a3a1823cf962bffbc465fe6148097975a8821ca7487e6e6c7ff4ee4de899fe67345676bb1c" );
7653  unhexify( tag_str, "1e7dec83830183d56f443a16471d" );
7654 
7655  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7656  if( 0 == 0 )
7657  {
7658  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7659 
7660  if( strcmp( "FAIL", "3d98cabca4afb7c1f6b8eeed521f4666ae252ac12d17ebf4a710b9a22d839b69458387ba4bbec2f6400e0cff80fbe4682c24efcd3b8c594d9b515ca7842c9d5988c42b59b6526c29a99256451e2927f5b956ef262f97c733dfa8bff73644473b9a8562bdfca748f4733ddce94a60024dfbfcde62fb3cbd7c3d955012d5338b91" ) == 0 )
7661  {
7662  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7663  }
7664  else
7665  {
7666  hexify( dst_str, output, pt_len );
7667 
7668  fct_chk( strcmp( (char *) dst_str, "3d98cabca4afb7c1f6b8eeed521f4666ae252ac12d17ebf4a710b9a22d839b69458387ba4bbec2f6400e0cff80fbe4682c24efcd3b8c594d9b515ca7842c9d5988c42b59b6526c29a99256451e2927f5b956ef262f97c733dfa8bff73644473b9a8562bdfca748f4733ddce94a60024dfbfcde62fb3cbd7c3d955012d5338b91" ) == 0 );
7669  }
7670  }
7671  }
7672  FCT_TEST_END();
7673 
7674 
7675  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024112_2)
7676  {
7677  unsigned char key_str[128];
7678  unsigned char src_str[128];
7679  unsigned char dst_str[257];
7680  unsigned char iv_str[128];
7681  unsigned char add_str[128];
7682  unsigned char tag_str[128];
7683  unsigned char output[128];
7684  gcm_context ctx;
7685  unsigned int key_len;
7686  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
7687  int ret;
7688 
7689  memset(key_str, 0x00, 128);
7690  memset(src_str, 0x00, 128);
7691  memset(dst_str, 0x00, 257);
7692  memset(iv_str, 0x00, 128);
7693  memset(add_str, 0x00, 128);
7694  memset(tag_str, 0x00, 128);
7695  memset(output, 0x00, 128);
7696 
7697  key_len = unhexify( key_str, "d89f06eb07744d43d44734faf9751d07" );
7698  pt_len = unhexify( src_str, "36cc3b2f563305208a03378f7dc036119f7de3fee77cefac06515853d36609a622382ed026c59783fbc0d9910767874c516e10c7bf3e3d104f73b3463c8d93a63418c76cb0d05e62e9c8642cb4f32caced2620912cb6c79e5110a27d5fba1ef3b4d0578077858526c5e4254365f2b2ab47a45df4af08980b3b7a9b66dff5b38c" );
7699  iv_len = unhexify( iv_str, "185f8d033713ee629e93561cf8d5acb8" );
7700  add_len = unhexify( add_str, "743bcb671d0aa1c547b5448d64d7c6b290777625ba28f25ca0fbf1fc66495a2fde0648a8db51039b0e7340d993aef8afb48269e660cb599837d1e46f72727762d887ee84c073d6136d1b0bc7d4c78f5673a4a6b73375937e8d54a47304845f38ca6b4f51cf14136a0826016535dc5ed003e38c3ac362b9d58ba8b555a05a1412" );
7701  unhexify( tag_str, "fcad48076eb03ebe85c6d64f6357" );
7702 
7703  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7704  if( 0 == 0 )
7705  {
7706  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7707 
7708  if( strcmp( "FAIL", "FAIL" ) == 0 )
7709  {
7710  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7711  }
7712  else
7713  {
7714  hexify( dst_str, output, pt_len );
7715 
7716  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
7717  }
7718  }
7719  }
7720  FCT_TEST_END();
7721 
7722 
7723  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024104_0)
7724  {
7725  unsigned char key_str[128];
7726  unsigned char src_str[128];
7727  unsigned char dst_str[257];
7728  unsigned char iv_str[128];
7729  unsigned char add_str[128];
7730  unsigned char tag_str[128];
7731  unsigned char output[128];
7732  gcm_context ctx;
7733  unsigned int key_len;
7734  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
7735  int ret;
7736 
7737  memset(key_str, 0x00, 128);
7738  memset(src_str, 0x00, 128);
7739  memset(dst_str, 0x00, 257);
7740  memset(iv_str, 0x00, 128);
7741  memset(add_str, 0x00, 128);
7742  memset(tag_str, 0x00, 128);
7743  memset(output, 0x00, 128);
7744 
7745  key_len = unhexify( key_str, "6150f14dc53f391e815acfabed9f9e20" );
7746  pt_len = unhexify( src_str, "fd8f337017e1b60d6618e6e4ad37c1f230cdeb78891579c2c63d4e6a4f7d2cb7252e99de333c73db45958808c08e91359c885a7385ab6f9ed98a27927a5b83c3a456ce2e01869712675e527155ba1e339ac14a3ccd7a4b87360902f2b8381308fe5a4eac5c90d0b84da4bf5b907de6ff3139cffd23b49a78750006100183032a" );
7747  iv_len = unhexify( iv_str, "7e92dd558bd2662c3a539dfe21a352cf" );
7748  add_len = unhexify( add_str, "9b4624e9118e6aa5dc65b69856638f77fd3f9f562046f50ba92a64e988258637932af7979f000505b84a71ff5dd7b60bad62586b1a8837a61c15a1a1ba7f06668272c28169915d7f06297b6c2a96c8c44203a422bfd25500c82e11274ffe07706365bfd3da34af4c4dd8ad7b620de7284a5af729bea9c4ed2631bdcba2ebdb7d" );
7749  unhexify( tag_str, "922a7b48ad5bf61e6d70751cfe" );
7750 
7751  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7752  if( 0 == 0 )
7753  {
7754  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7755 
7756  if( strcmp( "FAIL", "f272a3ee9b981f97785cc6fad350e516d72d402dae0d8a531c064ec64598b2a5760f9b279c10aa1ff71bec07300ab0373187138e7a103fc4130105afa6b6346f3d368b40d6f542375de97878ad4d976d64c5c4968a17be2b1757a17c03100231c34721250cd37cc596678764083ade89ae3b1a2151ff9151edcd7ba0eb8a4649" ) == 0 )
7757  {
7758  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7759  }
7760  else
7761  {
7762  hexify( dst_str, output, pt_len );
7763 
7764  fct_chk( strcmp( (char *) dst_str, "f272a3ee9b981f97785cc6fad350e516d72d402dae0d8a531c064ec64598b2a5760f9b279c10aa1ff71bec07300ab0373187138e7a103fc4130105afa6b6346f3d368b40d6f542375de97878ad4d976d64c5c4968a17be2b1757a17c03100231c34721250cd37cc596678764083ade89ae3b1a2151ff9151edcd7ba0eb8a4649" ) == 0 );
7765  }
7766  }
7767  }
7768  FCT_TEST_END();
7769 
7770 
7771  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024104_1)
7772  {
7773  unsigned char key_str[128];
7774  unsigned char src_str[128];
7775  unsigned char dst_str[257];
7776  unsigned char iv_str[128];
7777  unsigned char add_str[128];
7778  unsigned char tag_str[128];
7779  unsigned char output[128];
7780  gcm_context ctx;
7781  unsigned int key_len;
7782  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
7783  int ret;
7784 
7785  memset(key_str, 0x00, 128);
7786  memset(src_str, 0x00, 128);
7787  memset(dst_str, 0x00, 257);
7788  memset(iv_str, 0x00, 128);
7789  memset(add_str, 0x00, 128);
7790  memset(tag_str, 0x00, 128);
7791  memset(output, 0x00, 128);
7792 
7793  key_len = unhexify( key_str, "3e8216072ed6fcde0fe0f636b27ed718" );
7794  pt_len = unhexify( src_str, "3b50f2a8dca9f70178503d861d9e37f5edfafc80ee023bfed390a477372986e4794175ec22ac038c3461aba50c9b2379cab48512946efdfe2cb9c12a858b373a5309324f410e6a05e88ba892759dbee6e486dc9665f66cb5950ea7e71317fa94abbebd67a3948746a998173fbbb4f14f9effbdf66d3b6e346053496a4b1934ce" );
7795  iv_len = unhexify( iv_str, "23a122cf363c3117b8c663388c760ee4" );
7796  add_len = unhexify( add_str, "28ce0b4a44fa83323e060f3ff6436b8829d4f842090296bdc952b6d4a6b1b1a66be06168c63c4643e6ac186f7ffd8d144f603b2d4bc0d65be48121676f9fa1f359029c512bebfd75075ff357bc55f20fc76d9f2477c9930f16408f9f09c5ae86efa2529d2f1449ceeb635b83ca13662860ef9ac04a3d8ab4605eccd2d9ae5a71" );
7797  unhexify( tag_str, "531a65cc5dfeca671cc64078d1" );
7798 
7799  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7800  if( 0 == 0 )
7801  {
7802  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7803 
7804  if( strcmp( "FAIL", "FAIL" ) == 0 )
7805  {
7806  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7807  }
7808  else
7809  {
7810  hexify( dst_str, output, pt_len );
7811 
7812  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
7813  }
7814  }
7815  }
7816  FCT_TEST_END();
7817 
7818 
7819  FCT_TEST_BGN(gcm_nist_validation_aes_12812810241024104_2)
7820  {
7821  unsigned char key_str[128];
7822  unsigned char src_str[128];
7823  unsigned char dst_str[257];
7824  unsigned char iv_str[128];
7825  unsigned char add_str[128];
7826  unsigned char tag_str[128];
7827  unsigned char output[128];
7828  gcm_context ctx;
7829  unsigned int key_len;
7830  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
7831  int ret;
7832 
7833  memset(key_str, 0x00, 128);
7834  memset(src_str, 0x00, 128);
7835  memset(dst_str, 0x00, 257);
7836  memset(iv_str, 0x00, 128);
7837  memset(add_str, 0x00, 128);
7838  memset(tag_str, 0x00, 128);
7839  memset(output, 0x00, 128);
7840 
7841  key_len = unhexify( key_str, "1af434b73a1210b08595ffa686079832" );
7842  pt_len = unhexify( src_str, "13f6c1c2d4edcf1438a7b4e85bcd1c84a989831a64d205e7854fce8817ddfceab67d10506ccf6ed9ce50080ef809e28e46cba7b0c96be6a811f59cd09cb3b7b3fe5073ee6763f40aee61e3e65356093f97deef5a8721d995e71db27a51f60a50e34ac3348852c445188cfc64337455f317f87535d465c6f96006f4079396eba3" );
7843  iv_len = unhexify( iv_str, "ae318f3cb881d1680f6afbf6713a9a2f" );
7844  add_len = unhexify( add_str, "3763c9241be0d9d9a9e46e64b12e107d16cca267ff87844c2325af910cc9a485c7015d95bbe62398864d079fb2b577ba0cfad923c24fa30691ad7d767d651eed4a33d0be8f06fed43f58b2e0bb04959f10b9e8e73bd80d3a6a8c8ce637bfbdb9d02c2b0a3dd8317c4997822031a35d34b3b61819b425c10c64e839b29874ddfb" );
7845  unhexify( tag_str, "2ae7350dd3d1909a73f8d64255" );
7846 
7847  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7848  if( 0 == 0 )
7849  {
7850  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7851 
7852  if( strcmp( "FAIL", "3cd2a770300ce4c85740666640936a0fe48888788702fc37e7a8296adb40b862ec799f257a16821adaa7315bd31e8dec60e4a8faeb8ba2ee606340f0219a6440e9c1d3168425e58fac02e8a88865f30649913d988353ab81f42a5ad43f960055f0877acda20f493208c2c40754fbf4ccee040975aa358ea3fe62cbd028c1611a" ) == 0 )
7853  {
7854  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7855  }
7856  else
7857  {
7858  hexify( dst_str, output, pt_len );
7859 
7860  fct_chk( strcmp( (char *) dst_str, "3cd2a770300ce4c85740666640936a0fe48888788702fc37e7a8296adb40b862ec799f257a16821adaa7315bd31e8dec60e4a8faeb8ba2ee606340f0219a6440e9c1d3168425e58fac02e8a88865f30649913d988353ab81f42a5ad43f960055f0877acda20f493208c2c40754fbf4ccee040975aa358ea3fe62cbd028c1611a" ) == 0 );
7861  }
7862  }
7863  }
7864  FCT_TEST_END();
7865 
7866 
7867  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102496_0)
7868  {
7869  unsigned char key_str[128];
7870  unsigned char src_str[128];
7871  unsigned char dst_str[257];
7872  unsigned char iv_str[128];
7873  unsigned char add_str[128];
7874  unsigned char tag_str[128];
7875  unsigned char output[128];
7876  gcm_context ctx;
7877  unsigned int key_len;
7878  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
7879  int ret;
7880 
7881  memset(key_str, 0x00, 128);
7882  memset(src_str, 0x00, 128);
7883  memset(dst_str, 0x00, 257);
7884  memset(iv_str, 0x00, 128);
7885  memset(add_str, 0x00, 128);
7886  memset(tag_str, 0x00, 128);
7887  memset(output, 0x00, 128);
7888 
7889  key_len = unhexify( key_str, "04036d2f5273c6ff5b8364aa595359c9" );
7890  pt_len = unhexify( src_str, "acf79b6099490af938fb5fd8913255b3daa22786b03356cdf3e0ffaf570f9f866047b8e15c9953f893d97e7098265297396868ebc383be8547e8ec9d974b6a65b5dc5147cdadef2e2ad96696e84e44f364c2ba18c8aabe21f99489957b2b5484bf3fb4fecaf5ddaa1d373e910059c978918a3d01b955de2adb475914bf2c2067" );
7891  iv_len = unhexify( iv_str, "edc433c381140dff929d9df9f62f4cb6" );
7892  add_len = unhexify( add_str, "404acfeeea342aeea8c8b7449af9e20ddf5b85dc7770d2144a4dd05959613d04d0cfece5a21cbb1a9175ddc9443ffacd2085332eb4c337a12a7bb294c95960e7c0bde4b8ab30a91e50267bbd0b8d2a4ed381409ea2e4c84f9a2070a793ce3c90ea8a4b140651b452674f85d5b76d0055df115608bf3a3c60996108023ebabe65" );
7893  unhexify( tag_str, "71f818f1a2b789fabbda8ec1" );
7894 
7895  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7896  if( 0 == 0 )
7897  {
7898  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7899 
7900  if( strcmp( "FAIL", "4729cb642304de928b9dca32bb3d7b7836dd3973bbccf3f013c8ff4b59eca56f5d34d1b8f030a7b581b2f8fdc1e22b76a4cbc10095559876736d318d6c96c5c64cbd9fbd1d8eb4df38a2d56640d67d490d03acc1cd32d3f377eb1907bbd600f21d740b578080ba9c6ddc7dc6c50cdcee41fec51499cb944713c0961fc64f5a70" ) == 0 )
7901  {
7902  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7903  }
7904  else
7905  {
7906  hexify( dst_str, output, pt_len );
7907 
7908  fct_chk( strcmp( (char *) dst_str, "4729cb642304de928b9dca32bb3d7b7836dd3973bbccf3f013c8ff4b59eca56f5d34d1b8f030a7b581b2f8fdc1e22b76a4cbc10095559876736d318d6c96c5c64cbd9fbd1d8eb4df38a2d56640d67d490d03acc1cd32d3f377eb1907bbd600f21d740b578080ba9c6ddc7dc6c50cdcee41fec51499cb944713c0961fc64f5a70" ) == 0 );
7909  }
7910  }
7911  }
7912  FCT_TEST_END();
7913 
7914 
7915  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102496_1)
7916  {
7917  unsigned char key_str[128];
7918  unsigned char src_str[128];
7919  unsigned char dst_str[257];
7920  unsigned char iv_str[128];
7921  unsigned char add_str[128];
7922  unsigned char tag_str[128];
7923  unsigned char output[128];
7924  gcm_context ctx;
7925  unsigned int key_len;
7926  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
7927  int ret;
7928 
7929  memset(key_str, 0x00, 128);
7930  memset(src_str, 0x00, 128);
7931  memset(dst_str, 0x00, 257);
7932  memset(iv_str, 0x00, 128);
7933  memset(add_str, 0x00, 128);
7934  memset(tag_str, 0x00, 128);
7935  memset(output, 0x00, 128);
7936 
7937  key_len = unhexify( key_str, "59fe44c6e28d025b2ad05e6e867051ab" );
7938  pt_len = unhexify( src_str, "20e66bae1215de9a87a0b878d39015d17e0d4542a1aaba2000cefbd5f892c26a410f55f0d7dc2f6b66690f2997032985e5516e068bfc6ec8a3669f566e280b0cefded519023b735ee3bcbfc5b6ce8203b727933a750f9bd515ec448c1f3a030aa0f40e607727a3239ebbe655d46b38a3d867e481ccf0fadbf0d59b665d2ed6b5" );
7939  iv_len = unhexify( iv_str, "eb0c30320029433f66d29b3fd5c6563b" );
7940  add_len = unhexify( add_str, "49b7418b87374b462d25309b1c06e3132a3c8f4a4fcf29fed58e0902509426be712639db21c076df7b83dcfcc2c2c8fcc88576f4622a4366eb42f84ebf760e3eb22b14f8b5ff83f06a6f04a924eaab05b912e126e80da22461abf7f1925fd72ebdf2aea335a044726e7c2ebbb2b8aeebab4f7de5e186b50f275b700794d895d8" );
7941  unhexify( tag_str, "296c4cdaeb94beb2847dc53d" );
7942 
7943  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7944  if( 0 == 0 )
7945  {
7946  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7947 
7948  if( strcmp( "FAIL", "FAIL" ) == 0 )
7949  {
7950  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7951  }
7952  else
7953  {
7954  hexify( dst_str, output, pt_len );
7955 
7956  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
7957  }
7958  }
7959  }
7960  FCT_TEST_END();
7961 
7962 
7963  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102496_2)
7964  {
7965  unsigned char key_str[128];
7966  unsigned char src_str[128];
7967  unsigned char dst_str[257];
7968  unsigned char iv_str[128];
7969  unsigned char add_str[128];
7970  unsigned char tag_str[128];
7971  unsigned char output[128];
7972  gcm_context ctx;
7973  unsigned int key_len;
7974  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
7975  int ret;
7976 
7977  memset(key_str, 0x00, 128);
7978  memset(src_str, 0x00, 128);
7979  memset(dst_str, 0x00, 257);
7980  memset(iv_str, 0x00, 128);
7981  memset(add_str, 0x00, 128);
7982  memset(tag_str, 0x00, 128);
7983  memset(output, 0x00, 128);
7984 
7985  key_len = unhexify( key_str, "c314264cee0e6db30ebe9b2f6d4991b2" );
7986  pt_len = unhexify( src_str, "d436ff9abfb044a332c4e009b591719a67b12a5366da0a66edf19605c34daa37588e15dd3da0d1a097215e469439de79cca74e04cd4904e5b4a6cb4e0ea54e6ba4e624ed6bd48be32d1ef68ffea1639a14e91a5914c2346ea526df95cbd4ad1b8ee842da210b35b6315c3075ecc267d51643c4b39202d0ad793cbb0045ebdc19" );
7987  iv_len = unhexify( iv_str, "4cd4431bb6dea8eb18ae74e4c35a6698" );
7988  add_len = unhexify( add_str, "0eeafbfd04f9a0ea18e5bdc688c7df27183f346187e9574b61222006f2b3e12e8d9d9bf1f0f15949ee1a7ee8e5c80ee903b8ba2860e15ccb999929f280200b159c2adca481748d0632a7b40601c45055f8cb5126148e6cbab2c76f543537ab54eb276188343cea3c4ab0d7b65b8754e55cfe3f6a5c41b6ea3c08b81fcecc968a" );
7989  unhexify( tag_str, "fda18d2f795d900f057fe872" );
7990 
7991  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
7992  if( 0 == 0 )
7993  {
7994  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
7995 
7996  if( strcmp( "FAIL", "cb9e0fb0ac13ca730b79e34745584b362d0716c344e4de90d8352b21117471ba12c97f193150b33774baee5e4a0f11b10428eaf0106c958e16aa46c5f6f3d99eed93d1b9ba3957bed05a8b9cc8c5511cf813a66dc7d773cb735b0523d8d6b0b80639b031ddc375f714c6dd50055320cd7ed44a471c8d5645c938a9005d0b5050" ) == 0 )
7997  {
7998  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
7999  }
8000  else
8001  {
8002  hexify( dst_str, output, pt_len );
8003 
8004  fct_chk( strcmp( (char *) dst_str, "cb9e0fb0ac13ca730b79e34745584b362d0716c344e4de90d8352b21117471ba12c97f193150b33774baee5e4a0f11b10428eaf0106c958e16aa46c5f6f3d99eed93d1b9ba3957bed05a8b9cc8c5511cf813a66dc7d773cb735b0523d8d6b0b80639b031ddc375f714c6dd50055320cd7ed44a471c8d5645c938a9005d0b5050" ) == 0 );
8005  }
8006  }
8007  }
8008  FCT_TEST_END();
8009 
8010 
8011  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102464_0)
8012  {
8013  unsigned char key_str[128];
8014  unsigned char src_str[128];
8015  unsigned char dst_str[257];
8016  unsigned char iv_str[128];
8017  unsigned char add_str[128];
8018  unsigned char tag_str[128];
8019  unsigned char output[128];
8020  gcm_context ctx;
8021  unsigned int key_len;
8022  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
8023  int ret;
8024 
8025  memset(key_str, 0x00, 128);
8026  memset(src_str, 0x00, 128);
8027  memset(dst_str, 0x00, 257);
8028  memset(iv_str, 0x00, 128);
8029  memset(add_str, 0x00, 128);
8030  memset(tag_str, 0x00, 128);
8031  memset(output, 0x00, 128);
8032 
8033  key_len = unhexify( key_str, "26072018bd0bda524b5beb66a622c63e" );
8034  pt_len = unhexify( src_str, "91c524b359dae3bc49117eebfa610672af1e7754054607317d4c417e7b1a68453f72d355468f825aeb7fde044b20049aed196ec6646cce1eeeccf06cb394286272b573220cdb846613ebc4683442dccc7a19ec86ef1ec971c115726584ae1f4008f94e47d1290d8b6b7a932cfe07165fd2b94e8f96d15f73bf72939c73f4bd11" );
8035  iv_len = unhexify( iv_str, "c783d6d3b8392160e3b68038b43cf1f4" );
8036  add_len = unhexify( add_str, "8ae7c809a9dc40a6732a7384e3c64abb359c1b09dcb752e5a6b584873e3890230c6fc572b9ad24d849766f849c73f060fc48f664c1af9e6707e223691b77e170966ed164e0cc25ede3fbc3541c480f75b71e7be88fe730d8b361ea2733c6f37e6a59621de6004e020894b51dfb525973d641efe8d5fd9077a0bbc9dc7933a5de" );
8037  unhexify( tag_str, "edffe55c60235556" );
8038 
8039  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8040  if( 0 == 0 )
8041  {
8042  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8043 
8044  if( strcmp( "FAIL", "FAIL" ) == 0 )
8045  {
8046  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8047  }
8048  else
8049  {
8050  hexify( dst_str, output, pt_len );
8051 
8052  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8053  }
8054  }
8055  }
8056  FCT_TEST_END();
8057 
8058 
8059  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102464_1)
8060  {
8061  unsigned char key_str[128];
8062  unsigned char src_str[128];
8063  unsigned char dst_str[257];
8064  unsigned char iv_str[128];
8065  unsigned char add_str[128];
8066  unsigned char tag_str[128];
8067  unsigned char output[128];
8068  gcm_context ctx;
8069  unsigned int key_len;
8070  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
8071  int ret;
8072 
8073  memset(key_str, 0x00, 128);
8074  memset(src_str, 0x00, 128);
8075  memset(dst_str, 0x00, 257);
8076  memset(iv_str, 0x00, 128);
8077  memset(add_str, 0x00, 128);
8078  memset(tag_str, 0x00, 128);
8079  memset(output, 0x00, 128);
8080 
8081  key_len = unhexify( key_str, "201751d3da98bd39ff4e5990a56cfea7" );
8082  pt_len = unhexify( src_str, "2965af0bde3565a00e61cebbfe0b51b5b5ee98dbbfff7b1b5bf61da5ba537e6f4cf5fa07d2b20e518232c4961e6bc3ae247b797429da5d7eee2fc675b07066ac2e670261c6e9a91d920c7076101d86d5ef422b58e74bdc1e0b1d58298d3ee0f510ee3a3f63a3bbc24a55be556e465c20525dd100e33815c2a128ac89574884c1" );
8083  iv_len = unhexify( iv_str, "6172468634bf4e5dda96f67d433062d7" );
8084  add_len = unhexify( add_str, "ae2d770f40706e1eaa36e087b0093ec11ed58afbde4695794745e7523be0a1e4e54daade393f68ba770956d1cfb267b083431851d713249ffe4b61227f1784769ce8c9127f54271526d54181513aca69dc013b2dfb4a5277f4798b1ff674bca79b3dec4a7a27fcf2905ae0ce03f727c315662cd906e57aa557d1023cce2acd84" );
8085  unhexify( tag_str, "66c247e5ad4e1d6a" );
8086 
8087  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8088  if( 0 == 0 )
8089  {
8090  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8091 
8092  if( strcmp( "FAIL", "efd064d4b4ef4c37b48ddf2fa6f5facc5e9cc4c3255b23a1e3765fabb5a339fa0eda754a5381b72989fc1323ff9a6bbaecd904eb4835e5a511b922927574673061ed8de23299ea1456054e7ebb62869878c34fb95e48c8385b5ebceecb962654cf1586b3f54e7887ce31850363e9a22be9e6fbc22e694db81aa055490495dbf2" ) == 0 )
8093  {
8094  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8095  }
8096  else
8097  {
8098  hexify( dst_str, output, pt_len );
8099 
8100  fct_chk( strcmp( (char *) dst_str, "efd064d4b4ef4c37b48ddf2fa6f5facc5e9cc4c3255b23a1e3765fabb5a339fa0eda754a5381b72989fc1323ff9a6bbaecd904eb4835e5a511b922927574673061ed8de23299ea1456054e7ebb62869878c34fb95e48c8385b5ebceecb962654cf1586b3f54e7887ce31850363e9a22be9e6fbc22e694db81aa055490495dbf2" ) == 0 );
8101  }
8102  }
8103  }
8104  FCT_TEST_END();
8105 
8106 
8107  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102464_2)
8108  {
8109  unsigned char key_str[128];
8110  unsigned char src_str[128];
8111  unsigned char dst_str[257];
8112  unsigned char iv_str[128];
8113  unsigned char add_str[128];
8114  unsigned char tag_str[128];
8115  unsigned char output[128];
8116  gcm_context ctx;
8117  unsigned int key_len;
8118  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
8119  int ret;
8120 
8121  memset(key_str, 0x00, 128);
8122  memset(src_str, 0x00, 128);
8123  memset(dst_str, 0x00, 257);
8124  memset(iv_str, 0x00, 128);
8125  memset(add_str, 0x00, 128);
8126  memset(tag_str, 0x00, 128);
8127  memset(output, 0x00, 128);
8128 
8129  key_len = unhexify( key_str, "3bc0dcb5261a641a08e6cb00d23e4deb" );
8130  pt_len = unhexify( src_str, "d533ad89a1a578db330c01b4e04d08238b020e36aebe87cf2b0bf0b01f1ce4197be8b0596e475a95946918152e8b334ba89f60486c31f0bd8773ca4ff1319fe92197088b131e728d64405441c4fb5466641f0b8682e6cb371f8a8936140b16677f6def8b3dd9cbf47a73f553f1dca4320ad76f387e92f910f9434543f0df0626" );
8131  iv_len = unhexify( iv_str, "16fa19f69fceed9e97173207158755a5" );
8132  add_len = unhexify( add_str, "92ddd3b98f08fc8538f6106f6434a1efa0a7441cc7f6fd0841103c2e4dd181ea0c9a4811b3cb1bad1986a44d8addabc02dd6980daf7d60405b38dadc836bb1d0620ceab84e0134aca7c30f9f9490436b27acfd7052f9d7f0379b8e7116571017add46b9976f4b41431d47bae6f5f34dc42410793bc26c84bfe84fb53ae138c85" );
8133  unhexify( tag_str, "f5289e1204ace3b2" );
8134 
8135  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8136  if( 0 == 0 )
8137  {
8138  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8139 
8140  if( strcmp( "FAIL", "be0c30deeffbe51706247928132002b24d29272eee6b9d618483868e67280236632fa1ae06f3ef793f67bd01b1b01f70a827367c1cd28f778910457c7cbd977dfefff1f84a522247e19b2fd01fa22ce67cef9503d45c80a5084741f04108f2462b7cdd06a8f1f044fea2b05e920bcc061fbc6910175d732f45102a63c76ae48c" ) == 0 )
8141  {
8142  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8143  }
8144  else
8145  {
8146  hexify( dst_str, output, pt_len );
8147 
8148  fct_chk( strcmp( (char *) dst_str, "be0c30deeffbe51706247928132002b24d29272eee6b9d618483868e67280236632fa1ae06f3ef793f67bd01b1b01f70a827367c1cd28f778910457c7cbd977dfefff1f84a522247e19b2fd01fa22ce67cef9503d45c80a5084741f04108f2462b7cdd06a8f1f044fea2b05e920bcc061fbc6910175d732f45102a63c76ae48c" ) == 0 );
8149  }
8150  }
8151  }
8152  FCT_TEST_END();
8153 
8154 
8155  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102432_0)
8156  {
8157  unsigned char key_str[128];
8158  unsigned char src_str[128];
8159  unsigned char dst_str[257];
8160  unsigned char iv_str[128];
8161  unsigned char add_str[128];
8162  unsigned char tag_str[128];
8163  unsigned char output[128];
8164  gcm_context ctx;
8165  unsigned int key_len;
8166  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
8167  int ret;
8168 
8169  memset(key_str, 0x00, 128);
8170  memset(src_str, 0x00, 128);
8171  memset(dst_str, 0x00, 257);
8172  memset(iv_str, 0x00, 128);
8173  memset(add_str, 0x00, 128);
8174  memset(tag_str, 0x00, 128);
8175  memset(output, 0x00, 128);
8176 
8177  key_len = unhexify( key_str, "239c15492d6deec979e79236baca4635" );
8178  pt_len = unhexify( src_str, "d64886ce5f5b4adb7fe8f95904bc1461749c931655b02819ffdd0ae31bad4175125aa68962f8e36ec834a7d53a191a74c937e81ec93ad9ce0d3b286d3c11ff1733c0b7780130768c120b1833933561cf07399ca49b912370ae34f0e49b9c8cb9920eddc6816ab2ae261c6d7f70058a9b83a494026f249e58c4c613eefafe6974" );
8179  iv_len = unhexify( iv_str, "916b8b5417578fa83d2e9e9b8e2e7f6b" );
8180  add_len = unhexify( add_str, "b39eb732bc296c555cc9f00cf4caaf37d012329f344a6b74a873baf0d8dde9631f5e57b45b957d6aec0f7978e573dd78b43d459b77756037cd64d10d49966eb3a2a08d0f4d5e4f5dcb8713f4e4756acdf9925c5fc6120c477f6dffc59b0b47a3d5efd32b8c9052b321bb9b5129e5c6a095d8de563601b34608456f58d7221f2d" );
8181  unhexify( tag_str, "fc08cbbe" );
8182 
8183  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8184  if( 0 == 0 )
8185  {
8186  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8187 
8188  if( strcmp( "FAIL", "95c169721ea007c3f292e4ec7562a426d9baa7d374fd82e1e48d1eaca93d891d5ffa9acf5e3bd82e713ac627141e26a8b654920baffab948401cc3c390d6eea9d7b78c4fcb080b0aa9222e4d51bf201ccfd9328995831435e065d92ad37ee41c7c4366cc1efe15c07fc0470608866aeea96997772ecf926934c5d02efe05f250" ) == 0 )
8189  {
8190  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8191  }
8192  else
8193  {
8194  hexify( dst_str, output, pt_len );
8195 
8196  fct_chk( strcmp( (char *) dst_str, "95c169721ea007c3f292e4ec7562a426d9baa7d374fd82e1e48d1eaca93d891d5ffa9acf5e3bd82e713ac627141e26a8b654920baffab948401cc3c390d6eea9d7b78c4fcb080b0aa9222e4d51bf201ccfd9328995831435e065d92ad37ee41c7c4366cc1efe15c07fc0470608866aeea96997772ecf926934c5d02efe05f250" ) == 0 );
8197  }
8198  }
8199  }
8200  FCT_TEST_END();
8201 
8202 
8203  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102432_1)
8204  {
8205  unsigned char key_str[128];
8206  unsigned char src_str[128];
8207  unsigned char dst_str[257];
8208  unsigned char iv_str[128];
8209  unsigned char add_str[128];
8210  unsigned char tag_str[128];
8211  unsigned char output[128];
8212  gcm_context ctx;
8213  unsigned int key_len;
8214  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
8215  int ret;
8216 
8217  memset(key_str, 0x00, 128);
8218  memset(src_str, 0x00, 128);
8219  memset(dst_str, 0x00, 257);
8220  memset(iv_str, 0x00, 128);
8221  memset(add_str, 0x00, 128);
8222  memset(tag_str, 0x00, 128);
8223  memset(output, 0x00, 128);
8224 
8225  key_len = unhexify( key_str, "db68a96e216b0dd9945f14b878487e03" );
8226  pt_len = unhexify( src_str, "5634196a32d4cbfa7a2f874a1e0f86287d2942090e0cc6a82bd5caf40136a27ddf524a17713ce4af04ca6cb640a7205cce4ac9cb2d0ab380d533e1e968089ea5740c0fcbfa51f2424008e0b89dc7b3396b224cfaed53b3ac0604879983d3e6e6d36053de4866f52976890f72b8f4b9505e4ebdd04c0497048c3ce19336133ea4" );
8227  iv_len = unhexify( iv_str, "8a1a72e7bb740ec37ea4619c3007f8ae" );
8228  add_len = unhexify( add_str, "1b4f37190a59a4fff41d348798d1829031204fd7ac2a1be7b5ea385567e95e2ace25bf9e324488dd3ab8ce7f29d4c9a4f4b1a8a97f774871ee825e2c17700128d3c55908d3b684a1f550fdb8b38149ff759c21debdd54e49d64d3e8aac803dfd81600464ed484749bb993f89d4224b3d7d55c756b454466ff9fd609019ed5e83" );
8229  unhexify( tag_str, "9251d3e3" );
8230 
8231  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8232  if( 0 == 0 )
8233  {
8234  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8235 
8236  if( strcmp( "FAIL", "0c6bb3ee5de5cbb4b39d85d509bcacb3dda63fa50897936531339882962e8dc54c285c8944768d12096d4a3c2b42ffa92603cee2da9b435ec52908fca6d38ed74f898fe0ffa761f96038ff7dfeccc65bb841c3457b8de1e97d9bee82e2911602ee2dc555b33a227424dea86d610d37c447776295b412b412903ad2cede5170b6" ) == 0 )
8237  {
8238  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8239  }
8240  else
8241  {
8242  hexify( dst_str, output, pt_len );
8243 
8244  fct_chk( strcmp( (char *) dst_str, "0c6bb3ee5de5cbb4b39d85d509bcacb3dda63fa50897936531339882962e8dc54c285c8944768d12096d4a3c2b42ffa92603cee2da9b435ec52908fca6d38ed74f898fe0ffa761f96038ff7dfeccc65bb841c3457b8de1e97d9bee82e2911602ee2dc555b33a227424dea86d610d37c447776295b412b412903ad2cede5170b6" ) == 0 );
8245  }
8246  }
8247  }
8248  FCT_TEST_END();
8249 
8250 
8251  FCT_TEST_BGN(gcm_nist_validation_aes_1281281024102432_2)
8252  {
8253  unsigned char key_str[128];
8254  unsigned char src_str[128];
8255  unsigned char dst_str[257];
8256  unsigned char iv_str[128];
8257  unsigned char add_str[128];
8258  unsigned char tag_str[128];
8259  unsigned char output[128];
8260  gcm_context ctx;
8261  unsigned int key_len;
8262  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
8263  int ret;
8264 
8265  memset(key_str, 0x00, 128);
8266  memset(src_str, 0x00, 128);
8267  memset(dst_str, 0x00, 257);
8268  memset(iv_str, 0x00, 128);
8269  memset(add_str, 0x00, 128);
8270  memset(tag_str, 0x00, 128);
8271  memset(output, 0x00, 128);
8272 
8273  key_len = unhexify( key_str, "659b9e729d12f68b73fdc2f7260ab114" );
8274  pt_len = unhexify( src_str, "fd0732a38224c3f16f58de3a7f333da2ecdb6eec92b469544a891966dd4f8fb64a711a793f1ef6a90e49765eacaccdd8cc438c2b57c51902d27a82ee4f24925a864a9513a74e734ddbf77204a99a3c0060fcfbaccae48fe509bc95c3d6e1b1592889c489801265715e6e4355a45357ce467c1caa2f1c3071bd3a9168a7d223e3" );
8275  iv_len = unhexify( iv_str, "459df18e2dfbd66d6ad04978432a6d97" );
8276  add_len = unhexify( add_str, "ee0b0b52a729c45b899cc924f46eb1908e55aaaeeaa0c4cdaacf57948a7993a6debd7b6cd7aa426dc3b3b6f56522ba3d5700a820b1697b8170bad9ca7caf1050f13d54fb1ddeb111086cb650e1c5f4a14b6a927205a83bf49f357576fd0f884a83b068154352076a6e36a5369436d2c8351f3e6bfec65b4816e3eb3f144ed7f9" );
8277  unhexify( tag_str, "8e5a6a79" );
8278 
8279  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8280  if( 0 == 0 )
8281  {
8282  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8283 
8284  if( strcmp( "FAIL", "FAIL" ) == 0 )
8285  {
8286  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8287  }
8288  else
8289  {
8290  hexify( dst_str, output, pt_len );
8291 
8292  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8293  }
8294  }
8295  }
8296  FCT_TEST_END();
8297 
8298 
8299  FCT_TEST_BGN(gcm_nist_validation_aes_19212800128_0)
8300  {
8301  unsigned char key_str[128];
8302  unsigned char src_str[128];
8303  unsigned char dst_str[257];
8304  unsigned char iv_str[128];
8305  unsigned char add_str[128];
8306  unsigned char tag_str[128];
8307  unsigned char output[128];
8308  gcm_context ctx;
8309  unsigned int key_len;
8310  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
8311  int ret;
8312 
8313  memset(key_str, 0x00, 128);
8314  memset(src_str, 0x00, 128);
8315  memset(dst_str, 0x00, 257);
8316  memset(iv_str, 0x00, 128);
8317  memset(add_str, 0x00, 128);
8318  memset(tag_str, 0x00, 128);
8319  memset(output, 0x00, 128);
8320 
8321  key_len = unhexify( key_str, "806766a4d2b6507cc4113bc0e46eebe120eacd948c24dc7f" );
8322  pt_len = unhexify( src_str, "" );
8323  iv_len = unhexify( iv_str, "4f801c772395c4519ec830980c8ca5a4" );
8324  add_len = unhexify( add_str, "" );
8325  unhexify( tag_str, "8fa16452b132bebc6aa521e92cb3b0ea" );
8326 
8327  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8328  if( 0 == 0 )
8329  {
8330  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8331 
8332  if( strcmp( "FAIL", "FAIL" ) == 0 )
8333  {
8334  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8335  }
8336  else
8337  {
8338  hexify( dst_str, output, pt_len );
8339 
8340  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8341  }
8342  }
8343  }
8344  FCT_TEST_END();
8345 
8346 
8347  FCT_TEST_BGN(gcm_nist_validation_aes_19212800128_1)
8348  {
8349  unsigned char key_str[128];
8350  unsigned char src_str[128];
8351  unsigned char dst_str[257];
8352  unsigned char iv_str[128];
8353  unsigned char add_str[128];
8354  unsigned char tag_str[128];
8355  unsigned char output[128];
8356  gcm_context ctx;
8357  unsigned int key_len;
8358  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
8359  int ret;
8360 
8361  memset(key_str, 0x00, 128);
8362  memset(src_str, 0x00, 128);
8363  memset(dst_str, 0x00, 257);
8364  memset(iv_str, 0x00, 128);
8365  memset(add_str, 0x00, 128);
8366  memset(tag_str, 0x00, 128);
8367  memset(output, 0x00, 128);
8368 
8369  key_len = unhexify( key_str, "0c2abdcd2e4ae4137509761a38e6ca436b99c21b141f28f5" );
8370  pt_len = unhexify( src_str, "" );
8371  iv_len = unhexify( iv_str, "335ca01a07081fea4e605eb5f23a778e" );
8372  add_len = unhexify( add_str, "" );
8373  unhexify( tag_str, "d7f475dfcb92a75bc8521c12bb2e8b86" );
8374 
8375  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8376  if( 0 == 0 )
8377  {
8378  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8379 
8380  if( strcmp( "FAIL", "FAIL" ) == 0 )
8381  {
8382  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8383  }
8384  else
8385  {
8386  hexify( dst_str, output, pt_len );
8387 
8388  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8389  }
8390  }
8391  }
8392  FCT_TEST_END();
8393 
8394 
8395  FCT_TEST_BGN(gcm_nist_validation_aes_19212800128_2)
8396  {
8397  unsigned char key_str[128];
8398  unsigned char src_str[128];
8399  unsigned char dst_str[257];
8400  unsigned char iv_str[128];
8401  unsigned char add_str[128];
8402  unsigned char tag_str[128];
8403  unsigned char output[128];
8404  gcm_context ctx;
8405  unsigned int key_len;
8406  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
8407  int ret;
8408 
8409  memset(key_str, 0x00, 128);
8410  memset(src_str, 0x00, 128);
8411  memset(dst_str, 0x00, 257);
8412  memset(iv_str, 0x00, 128);
8413  memset(add_str, 0x00, 128);
8414  memset(tag_str, 0x00, 128);
8415  memset(output, 0x00, 128);
8416 
8417  key_len = unhexify( key_str, "eef490a0c2ecb32472e1654184340cc7433c34da981c062d" );
8418  pt_len = unhexify( src_str, "" );
8419  iv_len = unhexify( iv_str, "d9172c3344d37ff93d2dcb2170ea5d01" );
8420  add_len = unhexify( add_str, "" );
8421  unhexify( tag_str, "017fef05260a496654896d4703db3888" );
8422 
8423  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8424  if( 0 == 0 )
8425  {
8426  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8427 
8428  if( strcmp( "FAIL", "FAIL" ) == 0 )
8429  {
8430  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8431  }
8432  else
8433  {
8434  hexify( dst_str, output, pt_len );
8435 
8436  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8437  }
8438  }
8439  }
8440  FCT_TEST_END();
8441 
8442 
8443  FCT_TEST_BGN(gcm_nist_validation_aes_19212800120_0)
8444  {
8445  unsigned char key_str[128];
8446  unsigned char src_str[128];
8447  unsigned char dst_str[257];
8448  unsigned char iv_str[128];
8449  unsigned char add_str[128];
8450  unsigned char tag_str[128];
8451  unsigned char output[128];
8452  gcm_context ctx;
8453  unsigned int key_len;
8454  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
8455  int ret;
8456 
8457  memset(key_str, 0x00, 128);
8458  memset(src_str, 0x00, 128);
8459  memset(dst_str, 0x00, 257);
8460  memset(iv_str, 0x00, 128);
8461  memset(add_str, 0x00, 128);
8462  memset(tag_str, 0x00, 128);
8463  memset(output, 0x00, 128);
8464 
8465  key_len = unhexify( key_str, "fe0c3490f1f0dba23cf5c64e6e1740d06f85e0afec6772f3" );
8466  pt_len = unhexify( src_str, "" );
8467  iv_len = unhexify( iv_str, "f47e915163fa3df7f6c15b9d69f53907" );
8468  add_len = unhexify( add_str, "" );
8469  unhexify( tag_str, "14e1a057a2e7ffbd2208e9c25dbba1" );
8470 
8471  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8472  if( 0 == 0 )
8473  {
8474  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8475 
8476  if( strcmp( "FAIL", "FAIL" ) == 0 )
8477  {
8478  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8479  }
8480  else
8481  {
8482  hexify( dst_str, output, pt_len );
8483 
8484  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8485  }
8486  }
8487  }
8488  FCT_TEST_END();
8489 
8490 
8491  FCT_TEST_BGN(gcm_nist_validation_aes_19212800120_1)
8492  {
8493  unsigned char key_str[128];
8494  unsigned char src_str[128];
8495  unsigned char dst_str[257];
8496  unsigned char iv_str[128];
8497  unsigned char add_str[128];
8498  unsigned char tag_str[128];
8499  unsigned char output[128];
8500  gcm_context ctx;
8501  unsigned int key_len;
8502  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
8503  int ret;
8504 
8505  memset(key_str, 0x00, 128);
8506  memset(src_str, 0x00, 128);
8507  memset(dst_str, 0x00, 257);
8508  memset(iv_str, 0x00, 128);
8509  memset(add_str, 0x00, 128);
8510  memset(tag_str, 0x00, 128);
8511  memset(output, 0x00, 128);
8512 
8513  key_len = unhexify( key_str, "4356b3b1f308df3573509945afe5268984f9d953f01096de" );
8514  pt_len = unhexify( src_str, "" );
8515  iv_len = unhexify( iv_str, "a35b397b34a14a8e24d05a37be4d1822" );
8516  add_len = unhexify( add_str, "" );
8517  unhexify( tag_str, "e045ecba220d22c80826b77a21b013" );
8518 
8519  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8520  if( 0 == 0 )
8521  {
8522  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8523 
8524  if( strcmp( "FAIL", "" ) == 0 )
8525  {
8526  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8527  }
8528  else
8529  {
8530  hexify( dst_str, output, pt_len );
8531 
8532  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
8533  }
8534  }
8535  }
8536  FCT_TEST_END();
8537 
8538 
8539  FCT_TEST_BGN(gcm_nist_validation_aes_19212800120_2)
8540  {
8541  unsigned char key_str[128];
8542  unsigned char src_str[128];
8543  unsigned char dst_str[257];
8544  unsigned char iv_str[128];
8545  unsigned char add_str[128];
8546  unsigned char tag_str[128];
8547  unsigned char output[128];
8548  gcm_context ctx;
8549  unsigned int key_len;
8550  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
8551  int ret;
8552 
8553  memset(key_str, 0x00, 128);
8554  memset(src_str, 0x00, 128);
8555  memset(dst_str, 0x00, 257);
8556  memset(iv_str, 0x00, 128);
8557  memset(add_str, 0x00, 128);
8558  memset(tag_str, 0x00, 128);
8559  memset(output, 0x00, 128);
8560 
8561  key_len = unhexify( key_str, "e2898937cc575c8bb7444413884deafe8eaf326be8849e42" );
8562  pt_len = unhexify( src_str, "" );
8563  iv_len = unhexify( iv_str, "169a449ccb3eb29805b15304d603b132" );
8564  add_len = unhexify( add_str, "" );
8565  unhexify( tag_str, "3a807251f3d6242849a69972b14f6d" );
8566 
8567  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8568  if( 0 == 0 )
8569  {
8570  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8571 
8572  if( strcmp( "FAIL", "FAIL" ) == 0 )
8573  {
8574  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8575  }
8576  else
8577  {
8578  hexify( dst_str, output, pt_len );
8579 
8580  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8581  }
8582  }
8583  }
8584  FCT_TEST_END();
8585 
8586 
8587  FCT_TEST_BGN(gcm_nist_validation_aes_19212800112_0)
8588  {
8589  unsigned char key_str[128];
8590  unsigned char src_str[128];
8591  unsigned char dst_str[257];
8592  unsigned char iv_str[128];
8593  unsigned char add_str[128];
8594  unsigned char tag_str[128];
8595  unsigned char output[128];
8596  gcm_context ctx;
8597  unsigned int key_len;
8598  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
8599  int ret;
8600 
8601  memset(key_str, 0x00, 128);
8602  memset(src_str, 0x00, 128);
8603  memset(dst_str, 0x00, 257);
8604  memset(iv_str, 0x00, 128);
8605  memset(add_str, 0x00, 128);
8606  memset(tag_str, 0x00, 128);
8607  memset(output, 0x00, 128);
8608 
8609  key_len = unhexify( key_str, "75683c7df0442e10b5368fcd6bb481f0bff8d95aae90487e" );
8610  pt_len = unhexify( src_str, "" );
8611  iv_len = unhexify( iv_str, "538641f7d1cc5c68715971cee607da73" );
8612  add_len = unhexify( add_str, "" );
8613  unhexify( tag_str, "07d68fffe417adc3397706d73b95" );
8614 
8615  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8616  if( 0 == 0 )
8617  {
8618  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8619 
8620  if( strcmp( "FAIL", "FAIL" ) == 0 )
8621  {
8622  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8623  }
8624  else
8625  {
8626  hexify( dst_str, output, pt_len );
8627 
8628  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8629  }
8630  }
8631  }
8632  FCT_TEST_END();
8633 
8634 
8635  FCT_TEST_BGN(gcm_nist_validation_aes_19212800112_1)
8636  {
8637  unsigned char key_str[128];
8638  unsigned char src_str[128];
8639  unsigned char dst_str[257];
8640  unsigned char iv_str[128];
8641  unsigned char add_str[128];
8642  unsigned char tag_str[128];
8643  unsigned char output[128];
8644  gcm_context ctx;
8645  unsigned int key_len;
8646  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
8647  int ret;
8648 
8649  memset(key_str, 0x00, 128);
8650  memset(src_str, 0x00, 128);
8651  memset(dst_str, 0x00, 257);
8652  memset(iv_str, 0x00, 128);
8653  memset(add_str, 0x00, 128);
8654  memset(tag_str, 0x00, 128);
8655  memset(output, 0x00, 128);
8656 
8657  key_len = unhexify( key_str, "0724ee1f317997ce77bb659446fcb5a557490f40597341c7" );
8658  pt_len = unhexify( src_str, "" );
8659  iv_len = unhexify( iv_str, "0d8eb78032d83c676820b2ef5ccc2cc8" );
8660  add_len = unhexify( add_str, "" );
8661  unhexify( tag_str, "7da181563b26c7aefeb29e71cc69" );
8662 
8663  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8664  if( 0 == 0 )
8665  {
8666  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8667 
8668  if( strcmp( "FAIL", "FAIL" ) == 0 )
8669  {
8670  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8671  }
8672  else
8673  {
8674  hexify( dst_str, output, pt_len );
8675 
8676  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8677  }
8678  }
8679  }
8680  FCT_TEST_END();
8681 
8682 
8683  FCT_TEST_BGN(gcm_nist_validation_aes_19212800112_2)
8684  {
8685  unsigned char key_str[128];
8686  unsigned char src_str[128];
8687  unsigned char dst_str[257];
8688  unsigned char iv_str[128];
8689  unsigned char add_str[128];
8690  unsigned char tag_str[128];
8691  unsigned char output[128];
8692  gcm_context ctx;
8693  unsigned int key_len;
8694  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
8695  int ret;
8696 
8697  memset(key_str, 0x00, 128);
8698  memset(src_str, 0x00, 128);
8699  memset(dst_str, 0x00, 257);
8700  memset(iv_str, 0x00, 128);
8701  memset(add_str, 0x00, 128);
8702  memset(tag_str, 0x00, 128);
8703  memset(output, 0x00, 128);
8704 
8705  key_len = unhexify( key_str, "be2f0f4ae4ab851b258ec5602628df261b6a69e309ff9043" );
8706  pt_len = unhexify( src_str, "" );
8707  iv_len = unhexify( iv_str, "646a91d83ae72b9b9e9fce64135cbf73" );
8708  add_len = unhexify( add_str, "" );
8709  unhexify( tag_str, "169e717e2bae42e3eb61d0a1a29b" );
8710 
8711  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8712  if( 0 == 0 )
8713  {
8714  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8715 
8716  if( strcmp( "FAIL", "FAIL" ) == 0 )
8717  {
8718  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8719  }
8720  else
8721  {
8722  hexify( dst_str, output, pt_len );
8723 
8724  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8725  }
8726  }
8727  }
8728  FCT_TEST_END();
8729 
8730 
8731  FCT_TEST_BGN(gcm_nist_validation_aes_19212800104_0)
8732  {
8733  unsigned char key_str[128];
8734  unsigned char src_str[128];
8735  unsigned char dst_str[257];
8736  unsigned char iv_str[128];
8737  unsigned char add_str[128];
8738  unsigned char tag_str[128];
8739  unsigned char output[128];
8740  gcm_context ctx;
8741  unsigned int key_len;
8742  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
8743  int ret;
8744 
8745  memset(key_str, 0x00, 128);
8746  memset(src_str, 0x00, 128);
8747  memset(dst_str, 0x00, 257);
8748  memset(iv_str, 0x00, 128);
8749  memset(add_str, 0x00, 128);
8750  memset(tag_str, 0x00, 128);
8751  memset(output, 0x00, 128);
8752 
8753  key_len = unhexify( key_str, "583c328daecd18c2ac5c83a0c263de194a4c73aa4700fe76" );
8754  pt_len = unhexify( src_str, "" );
8755  iv_len = unhexify( iv_str, "55e10d5e9b438b02505d30f211b16fea" );
8756  add_len = unhexify( add_str, "" );
8757  unhexify( tag_str, "95c0a4ea9e80f91a4acce500f7" );
8758 
8759  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8760  if( 0 == 0 )
8761  {
8762  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8763 
8764  if( strcmp( "FAIL", "FAIL" ) == 0 )
8765  {
8766  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8767  }
8768  else
8769  {
8770  hexify( dst_str, output, pt_len );
8771 
8772  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8773  }
8774  }
8775  }
8776  FCT_TEST_END();
8777 
8778 
8779  FCT_TEST_BGN(gcm_nist_validation_aes_19212800104_1)
8780  {
8781  unsigned char key_str[128];
8782  unsigned char src_str[128];
8783  unsigned char dst_str[257];
8784  unsigned char iv_str[128];
8785  unsigned char add_str[128];
8786  unsigned char tag_str[128];
8787  unsigned char output[128];
8788  gcm_context ctx;
8789  unsigned int key_len;
8790  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
8791  int ret;
8792 
8793  memset(key_str, 0x00, 128);
8794  memset(src_str, 0x00, 128);
8795  memset(dst_str, 0x00, 257);
8796  memset(iv_str, 0x00, 128);
8797  memset(add_str, 0x00, 128);
8798  memset(tag_str, 0x00, 128);
8799  memset(output, 0x00, 128);
8800 
8801  key_len = unhexify( key_str, "b40857e7e6f26050f1e9a6cbe05e15a0ba07c2055634ad47" );
8802  pt_len = unhexify( src_str, "" );
8803  iv_len = unhexify( iv_str, "e25ef162a4295d7d24de75a673172346" );
8804  add_len = unhexify( add_str, "" );
8805  unhexify( tag_str, "89ea4d1f34edb716b322ea7f6f" );
8806 
8807  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8808  if( 0 == 0 )
8809  {
8810  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8811 
8812  if( strcmp( "FAIL", "FAIL" ) == 0 )
8813  {
8814  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8815  }
8816  else
8817  {
8818  hexify( dst_str, output, pt_len );
8819 
8820  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8821  }
8822  }
8823  }
8824  FCT_TEST_END();
8825 
8826 
8827  FCT_TEST_BGN(gcm_nist_validation_aes_19212800104_2)
8828  {
8829  unsigned char key_str[128];
8830  unsigned char src_str[128];
8831  unsigned char dst_str[257];
8832  unsigned char iv_str[128];
8833  unsigned char add_str[128];
8834  unsigned char tag_str[128];
8835  unsigned char output[128];
8836  gcm_context ctx;
8837  unsigned int key_len;
8838  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
8839  int ret;
8840 
8841  memset(key_str, 0x00, 128);
8842  memset(src_str, 0x00, 128);
8843  memset(dst_str, 0x00, 257);
8844  memset(iv_str, 0x00, 128);
8845  memset(add_str, 0x00, 128);
8846  memset(tag_str, 0x00, 128);
8847  memset(output, 0x00, 128);
8848 
8849  key_len = unhexify( key_str, "627008956e31fea497fb120b438a2a043c23b1b38dc6bc10" );
8850  pt_len = unhexify( src_str, "" );
8851  iv_len = unhexify( iv_str, "08ea464baac54469b0498419d83820e6" );
8852  add_len = unhexify( add_str, "" );
8853  unhexify( tag_str, "ab064a8d380fe2cda38e61f9e1" );
8854 
8855  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8856  if( 0 == 0 )
8857  {
8858  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8859 
8860  if( strcmp( "FAIL", "FAIL" ) == 0 )
8861  {
8862  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8863  }
8864  else
8865  {
8866  hexify( dst_str, output, pt_len );
8867 
8868  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8869  }
8870  }
8871  }
8872  FCT_TEST_END();
8873 
8874 
8875  FCT_TEST_BGN(gcm_nist_validation_aes_1921280096_0)
8876  {
8877  unsigned char key_str[128];
8878  unsigned char src_str[128];
8879  unsigned char dst_str[257];
8880  unsigned char iv_str[128];
8881  unsigned char add_str[128];
8882  unsigned char tag_str[128];
8883  unsigned char output[128];
8884  gcm_context ctx;
8885  unsigned int key_len;
8886  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
8887  int ret;
8888 
8889  memset(key_str, 0x00, 128);
8890  memset(src_str, 0x00, 128);
8891  memset(dst_str, 0x00, 257);
8892  memset(iv_str, 0x00, 128);
8893  memset(add_str, 0x00, 128);
8894  memset(tag_str, 0x00, 128);
8895  memset(output, 0x00, 128);
8896 
8897  key_len = unhexify( key_str, "8c386d67d7c2bfd46b8571d8685b35741e87a3ed4a46c9db" );
8898  pt_len = unhexify( src_str, "" );
8899  iv_len = unhexify( iv_str, "766996fb67ace9e6a22d7f802455d4ef" );
8900  add_len = unhexify( add_str, "" );
8901  unhexify( tag_str, "9a641be173dc3557ea015372" );
8902 
8903  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8904  if( 0 == 0 )
8905  {
8906  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8907 
8908  if( strcmp( "FAIL", "" ) == 0 )
8909  {
8910  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8911  }
8912  else
8913  {
8914  hexify( dst_str, output, pt_len );
8915 
8916  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
8917  }
8918  }
8919  }
8920  FCT_TEST_END();
8921 
8922 
8923  FCT_TEST_BGN(gcm_nist_validation_aes_1921280096_1)
8924  {
8925  unsigned char key_str[128];
8926  unsigned char src_str[128];
8927  unsigned char dst_str[257];
8928  unsigned char iv_str[128];
8929  unsigned char add_str[128];
8930  unsigned char tag_str[128];
8931  unsigned char output[128];
8932  gcm_context ctx;
8933  unsigned int key_len;
8934  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
8935  int ret;
8936 
8937  memset(key_str, 0x00, 128);
8938  memset(src_str, 0x00, 128);
8939  memset(dst_str, 0x00, 257);
8940  memset(iv_str, 0x00, 128);
8941  memset(add_str, 0x00, 128);
8942  memset(tag_str, 0x00, 128);
8943  memset(output, 0x00, 128);
8944 
8945  key_len = unhexify( key_str, "711bc5aa6b94fa3287fad0167ac1a9ef5e8e01c16a79e95a" );
8946  pt_len = unhexify( src_str, "" );
8947  iv_len = unhexify( iv_str, "75cdb8b83017f3dc5ac8733016ab47c7" );
8948  add_len = unhexify( add_str, "" );
8949  unhexify( tag_str, "81e3a5580234d8e0b2204bc3" );
8950 
8951  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
8952  if( 0 == 0 )
8953  {
8954  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
8955 
8956  if( strcmp( "FAIL", "FAIL" ) == 0 )
8957  {
8958  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
8959  }
8960  else
8961  {
8962  hexify( dst_str, output, pt_len );
8963 
8964  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
8965  }
8966  }
8967  }
8968  FCT_TEST_END();
8969 
8970 
8971  FCT_TEST_BGN(gcm_nist_validation_aes_1921280096_2)
8972  {
8973  unsigned char key_str[128];
8974  unsigned char src_str[128];
8975  unsigned char dst_str[257];
8976  unsigned char iv_str[128];
8977  unsigned char add_str[128];
8978  unsigned char tag_str[128];
8979  unsigned char output[128];
8980  gcm_context ctx;
8981  unsigned int key_len;
8982  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
8983  int ret;
8984 
8985  memset(key_str, 0x00, 128);
8986  memset(src_str, 0x00, 128);
8987  memset(dst_str, 0x00, 257);
8988  memset(iv_str, 0x00, 128);
8989  memset(add_str, 0x00, 128);
8990  memset(tag_str, 0x00, 128);
8991  memset(output, 0x00, 128);
8992 
8993  key_len = unhexify( key_str, "c74620828402e0bdf3f7a5353668505dc1550a31debce59a" );
8994  pt_len = unhexify( src_str, "" );
8995  iv_len = unhexify( iv_str, "cfbefe265583ab3a2285e8080141ba48" );
8996  add_len = unhexify( add_str, "" );
8997  unhexify( tag_str, "355a43bcebbe7f72b6cd27ea" );
8998 
8999  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9000  if( 0 == 0 )
9001  {
9002  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9003 
9004  if( strcmp( "FAIL", "FAIL" ) == 0 )
9005  {
9006  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9007  }
9008  else
9009  {
9010  hexify( dst_str, output, pt_len );
9011 
9012  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9013  }
9014  }
9015  }
9016  FCT_TEST_END();
9017 
9018 
9019  FCT_TEST_BGN(gcm_nist_validation_aes_1921280064_0)
9020  {
9021  unsigned char key_str[128];
9022  unsigned char src_str[128];
9023  unsigned char dst_str[257];
9024  unsigned char iv_str[128];
9025  unsigned char add_str[128];
9026  unsigned char tag_str[128];
9027  unsigned char output[128];
9028  gcm_context ctx;
9029  unsigned int key_len;
9030  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
9031  int ret;
9032 
9033  memset(key_str, 0x00, 128);
9034  memset(src_str, 0x00, 128);
9035  memset(dst_str, 0x00, 257);
9036  memset(iv_str, 0x00, 128);
9037  memset(add_str, 0x00, 128);
9038  memset(tag_str, 0x00, 128);
9039  memset(output, 0x00, 128);
9040 
9041  key_len = unhexify( key_str, "1eb53aa548b41bfdc85c657ebdebdae0c7e525a6432bc012" );
9042  pt_len = unhexify( src_str, "" );
9043  iv_len = unhexify( iv_str, "37ffc64d4b2d9c82dd17d1ad3076d82b" );
9044  add_len = unhexify( add_str, "" );
9045  unhexify( tag_str, "34b8e037084b3f2d" );
9046 
9047  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9048  if( 0 == 0 )
9049  {
9050  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9051 
9052  if( strcmp( "FAIL", "FAIL" ) == 0 )
9053  {
9054  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9055  }
9056  else
9057  {
9058  hexify( dst_str, output, pt_len );
9059 
9060  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9061  }
9062  }
9063  }
9064  FCT_TEST_END();
9065 
9066 
9067  FCT_TEST_BGN(gcm_nist_validation_aes_1921280064_1)
9068  {
9069  unsigned char key_str[128];
9070  unsigned char src_str[128];
9071  unsigned char dst_str[257];
9072  unsigned char iv_str[128];
9073  unsigned char add_str[128];
9074  unsigned char tag_str[128];
9075  unsigned char output[128];
9076  gcm_context ctx;
9077  unsigned int key_len;
9078  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
9079  int ret;
9080 
9081  memset(key_str, 0x00, 128);
9082  memset(src_str, 0x00, 128);
9083  memset(dst_str, 0x00, 257);
9084  memset(iv_str, 0x00, 128);
9085  memset(add_str, 0x00, 128);
9086  memset(tag_str, 0x00, 128);
9087  memset(output, 0x00, 128);
9088 
9089  key_len = unhexify( key_str, "50d077575f6db91024a8e564db83324539e9b7add7bb98e4" );
9090  pt_len = unhexify( src_str, "" );
9091  iv_len = unhexify( iv_str, "118d0283294d4084127cce4b0cd5b5fa" );
9092  add_len = unhexify( add_str, "" );
9093  unhexify( tag_str, "507a361d8ac59882" );
9094 
9095  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9096  if( 0 == 0 )
9097  {
9098  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9099 
9100  if( strcmp( "FAIL", "FAIL" ) == 0 )
9101  {
9102  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9103  }
9104  else
9105  {
9106  hexify( dst_str, output, pt_len );
9107 
9108  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9109  }
9110  }
9111  }
9112  FCT_TEST_END();
9113 
9114 
9115  FCT_TEST_BGN(gcm_nist_validation_aes_1921280064_2)
9116  {
9117  unsigned char key_str[128];
9118  unsigned char src_str[128];
9119  unsigned char dst_str[257];
9120  unsigned char iv_str[128];
9121  unsigned char add_str[128];
9122  unsigned char tag_str[128];
9123  unsigned char output[128];
9124  gcm_context ctx;
9125  unsigned int key_len;
9126  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
9127  int ret;
9128 
9129  memset(key_str, 0x00, 128);
9130  memset(src_str, 0x00, 128);
9131  memset(dst_str, 0x00, 257);
9132  memset(iv_str, 0x00, 128);
9133  memset(add_str, 0x00, 128);
9134  memset(tag_str, 0x00, 128);
9135  memset(output, 0x00, 128);
9136 
9137  key_len = unhexify( key_str, "d9ddca0807305025d61919ed7893d7d5c5a3c9f012f4842f" );
9138  pt_len = unhexify( src_str, "" );
9139  iv_len = unhexify( iv_str, "b78d518b6c41a9e031a00b10fb178327" );
9140  add_len = unhexify( add_str, "" );
9141  unhexify( tag_str, "f401d546c8b739ff" );
9142 
9143  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9144  if( 0 == 0 )
9145  {
9146  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9147 
9148  if( strcmp( "FAIL", "" ) == 0 )
9149  {
9150  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9151  }
9152  else
9153  {
9154  hexify( dst_str, output, pt_len );
9155 
9156  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
9157  }
9158  }
9159  }
9160  FCT_TEST_END();
9161 
9162 
9163  FCT_TEST_BGN(gcm_nist_validation_aes_1921280032_0)
9164  {
9165  unsigned char key_str[128];
9166  unsigned char src_str[128];
9167  unsigned char dst_str[257];
9168  unsigned char iv_str[128];
9169  unsigned char add_str[128];
9170  unsigned char tag_str[128];
9171  unsigned char output[128];
9172  gcm_context ctx;
9173  unsigned int key_len;
9174  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
9175  int ret;
9176 
9177  memset(key_str, 0x00, 128);
9178  memset(src_str, 0x00, 128);
9179  memset(dst_str, 0x00, 257);
9180  memset(iv_str, 0x00, 128);
9181  memset(add_str, 0x00, 128);
9182  memset(tag_str, 0x00, 128);
9183  memset(output, 0x00, 128);
9184 
9185  key_len = unhexify( key_str, "6ed8d8afde4dc3872cbc274d7c47b719205518496dd7951d" );
9186  pt_len = unhexify( src_str, "" );
9187  iv_len = unhexify( iv_str, "14eb280288740d464e3b8f296c642daa" );
9188  add_len = unhexify( add_str, "" );
9189  unhexify( tag_str, "39e64d7a" );
9190 
9191  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9192  if( 0 == 0 )
9193  {
9194  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9195 
9196  if( strcmp( "FAIL", "" ) == 0 )
9197  {
9198  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9199  }
9200  else
9201  {
9202  hexify( dst_str, output, pt_len );
9203 
9204  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
9205  }
9206  }
9207  }
9208  FCT_TEST_END();
9209 
9210 
9211  FCT_TEST_BGN(gcm_nist_validation_aes_1921280032_1)
9212  {
9213  unsigned char key_str[128];
9214  unsigned char src_str[128];
9215  unsigned char dst_str[257];
9216  unsigned char iv_str[128];
9217  unsigned char add_str[128];
9218  unsigned char tag_str[128];
9219  unsigned char output[128];
9220  gcm_context ctx;
9221  unsigned int key_len;
9222  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
9223  int ret;
9224 
9225  memset(key_str, 0x00, 128);
9226  memset(src_str, 0x00, 128);
9227  memset(dst_str, 0x00, 257);
9228  memset(iv_str, 0x00, 128);
9229  memset(add_str, 0x00, 128);
9230  memset(tag_str, 0x00, 128);
9231  memset(output, 0x00, 128);
9232 
9233  key_len = unhexify( key_str, "80aace5ab74f261bc09ac6f66898f69e7f348f805d52404d" );
9234  pt_len = unhexify( src_str, "" );
9235  iv_len = unhexify( iv_str, "f54bf4aac8fb631c8b6ff5e96465fae6" );
9236  add_len = unhexify( add_str, "" );
9237  unhexify( tag_str, "1ec1c1a1" );
9238 
9239  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9240  if( 0 == 0 )
9241  {
9242  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9243 
9244  if( strcmp( "FAIL", "" ) == 0 )
9245  {
9246  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9247  }
9248  else
9249  {
9250  hexify( dst_str, output, pt_len );
9251 
9252  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
9253  }
9254  }
9255  }
9256  FCT_TEST_END();
9257 
9258 
9259  FCT_TEST_BGN(gcm_nist_validation_aes_1921280032_2)
9260  {
9261  unsigned char key_str[128];
9262  unsigned char src_str[128];
9263  unsigned char dst_str[257];
9264  unsigned char iv_str[128];
9265  unsigned char add_str[128];
9266  unsigned char tag_str[128];
9267  unsigned char output[128];
9268  gcm_context ctx;
9269  unsigned int key_len;
9270  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
9271  int ret;
9272 
9273  memset(key_str, 0x00, 128);
9274  memset(src_str, 0x00, 128);
9275  memset(dst_str, 0x00, 257);
9276  memset(iv_str, 0x00, 128);
9277  memset(add_str, 0x00, 128);
9278  memset(tag_str, 0x00, 128);
9279  memset(output, 0x00, 128);
9280 
9281  key_len = unhexify( key_str, "23b76efd0dbc8d501885ab7d43a7dacde91edd9cde1e1048" );
9282  pt_len = unhexify( src_str, "" );
9283  iv_len = unhexify( iv_str, "75532d15e582e6c477b411e727d4171e" );
9284  add_len = unhexify( add_str, "" );
9285  unhexify( tag_str, "76a0e017" );
9286 
9287  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9288  if( 0 == 0 )
9289  {
9290  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9291 
9292  if( strcmp( "FAIL", "FAIL" ) == 0 )
9293  {
9294  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9295  }
9296  else
9297  {
9298  hexify( dst_str, output, pt_len );
9299 
9300  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9301  }
9302  }
9303  }
9304  FCT_TEST_END();
9305 
9306 
9307  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024128_0)
9308  {
9309  unsigned char key_str[128];
9310  unsigned char src_str[128];
9311  unsigned char dst_str[257];
9312  unsigned char iv_str[128];
9313  unsigned char add_str[128];
9314  unsigned char tag_str[128];
9315  unsigned char output[128];
9316  gcm_context ctx;
9317  unsigned int key_len;
9318  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
9319  int ret;
9320 
9321  memset(key_str, 0x00, 128);
9322  memset(src_str, 0x00, 128);
9323  memset(dst_str, 0x00, 257);
9324  memset(iv_str, 0x00, 128);
9325  memset(add_str, 0x00, 128);
9326  memset(tag_str, 0x00, 128);
9327  memset(output, 0x00, 128);
9328 
9329  key_len = unhexify( key_str, "94c50453dd3ef7f7ea763ae13fa34debb9c1198abbf32326" );
9330  pt_len = unhexify( src_str, "" );
9331  iv_len = unhexify( iv_str, "1afe962bc46e36099165552ddb329ac6" );
9332  add_len = unhexify( add_str, "b2920dd9b0325a87e8edda8db560bfe287e44df79cf61edba3b2c95e34629638ecb86584f05a303603065e63323523f6ccc5b605679d1722cde5561f89d268d5f8db8e6bdffda4839c4a04982e8314da78e89f8f8ad9c0fee86332906bf78d2f20afcaabdc282008c6d09df2bfe9be2c9027bb49268b8be8936be39fa8b1ae03" );
9333  unhexify( tag_str, "51e1f19a7dea5cfe9b9ca9d09096c3e7" );
9334 
9335  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9336  if( 0 == 0 )
9337  {
9338  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9339 
9340  if( strcmp( "FAIL", "FAIL" ) == 0 )
9341  {
9342  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9343  }
9344  else
9345  {
9346  hexify( dst_str, output, pt_len );
9347 
9348  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9349  }
9350  }
9351  }
9352  FCT_TEST_END();
9353 
9354 
9355  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024128_1)
9356  {
9357  unsigned char key_str[128];
9358  unsigned char src_str[128];
9359  unsigned char dst_str[257];
9360  unsigned char iv_str[128];
9361  unsigned char add_str[128];
9362  unsigned char tag_str[128];
9363  unsigned char output[128];
9364  gcm_context ctx;
9365  unsigned int key_len;
9366  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
9367  int ret;
9368 
9369  memset(key_str, 0x00, 128);
9370  memset(src_str, 0x00, 128);
9371  memset(dst_str, 0x00, 257);
9372  memset(iv_str, 0x00, 128);
9373  memset(add_str, 0x00, 128);
9374  memset(tag_str, 0x00, 128);
9375  memset(output, 0x00, 128);
9376 
9377  key_len = unhexify( key_str, "c6a98102af3d875bcdebe594661d3a6b376970c02b11d019" );
9378  pt_len = unhexify( src_str, "" );
9379  iv_len = unhexify( iv_str, "bea8cd85a28a2c05bf7406b8eef1efcc" );
9380  add_len = unhexify( add_str, "f2f80e2c042092cc7240b598ab30fad055bce85408aa0f8cefaf8a7204f0e2acb87c78f46a5867b1f1c19461cbf5ed5d2ca21c96a63fb1f42f10f394952e63520795c56df77d6a04cb5ad006ee865a47dc2349a814a630b3d4c4e0fd149f51e8fa846656ea569fd29a1ebafc061446eb80ec182f833f1f6d9083545abf52fa4c" );
9381  unhexify( tag_str, "04b80f25ae9d07f5fd8220263ac3f2f7" );
9382 
9383  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9384  if( 0 == 0 )
9385  {
9386  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9387 
9388  if( strcmp( "FAIL", "" ) == 0 )
9389  {
9390  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9391  }
9392  else
9393  {
9394  hexify( dst_str, output, pt_len );
9395 
9396  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
9397  }
9398  }
9399  }
9400  FCT_TEST_END();
9401 
9402 
9403  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024128_2)
9404  {
9405  unsigned char key_str[128];
9406  unsigned char src_str[128];
9407  unsigned char dst_str[257];
9408  unsigned char iv_str[128];
9409  unsigned char add_str[128];
9410  unsigned char tag_str[128];
9411  unsigned char output[128];
9412  gcm_context ctx;
9413  unsigned int key_len;
9414  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
9415  int ret;
9416 
9417  memset(key_str, 0x00, 128);
9418  memset(src_str, 0x00, 128);
9419  memset(dst_str, 0x00, 257);
9420  memset(iv_str, 0x00, 128);
9421  memset(add_str, 0x00, 128);
9422  memset(tag_str, 0x00, 128);
9423  memset(output, 0x00, 128);
9424 
9425  key_len = unhexify( key_str, "ec3cc45a22fdc7cc79ed658d9e9dbc138dcc7d6e795cba1a" );
9426  pt_len = unhexify( src_str, "" );
9427  iv_len = unhexify( iv_str, "b10d9c70205e142704f9d1f74caee0f6" );
9428  add_len = unhexify( add_str, "714994017c169c574aaff2f8bad15f8fa6a385117f5405f74846eca873ca4a8f4876adf704f2fcaff2dfa75c17afefd08a4707292debc6d9fafda6244ca509bc52b0c6b70f09b14c0d7c667583c091d4064e241ba1f82dd43dc3ea4b8922be65faf5583f6b21ff5b22d3632eb4a426675648250e4b3e37c688d6129b954ef6a8" );
9429  unhexify( tag_str, "d22407fd3ae1921d1b380461d2e60210" );
9430 
9431  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9432  if( 0 == 0 )
9433  {
9434  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9435 
9436  if( strcmp( "FAIL", "" ) == 0 )
9437  {
9438  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9439  }
9440  else
9441  {
9442  hexify( dst_str, output, pt_len );
9443 
9444  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
9445  }
9446  }
9447  }
9448  FCT_TEST_END();
9449 
9450 
9451  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024120_0)
9452  {
9453  unsigned char key_str[128];
9454  unsigned char src_str[128];
9455  unsigned char dst_str[257];
9456  unsigned char iv_str[128];
9457  unsigned char add_str[128];
9458  unsigned char tag_str[128];
9459  unsigned char output[128];
9460  gcm_context ctx;
9461  unsigned int key_len;
9462  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
9463  int ret;
9464 
9465  memset(key_str, 0x00, 128);
9466  memset(src_str, 0x00, 128);
9467  memset(dst_str, 0x00, 257);
9468  memset(iv_str, 0x00, 128);
9469  memset(add_str, 0x00, 128);
9470  memset(tag_str, 0x00, 128);
9471  memset(output, 0x00, 128);
9472 
9473  key_len = unhexify( key_str, "5a32ebc7a2338038ced36d2b85cbc6c45cca9845a7c5aa99" );
9474  pt_len = unhexify( src_str, "" );
9475  iv_len = unhexify( iv_str, "9afe0882e418c9af205eeb90e131d212" );
9476  add_len = unhexify( add_str, "61ff8a8bc22803f17e8e9f01aff865bc7d3083ff413ce392a989e46ebed5114894de906f7d36439024d8f2e69cc815ac043fff2f75169f6c9aa9761ff32d10a1353213ac756cb84bd3613f8261ef390e1d00c3a8fb82764b0cda4e0049219e87d2e92c38f78ffac242391f838a248f608bb2b56b31bbb453d1098e99d079ea1b" );
9477  unhexify( tag_str, "fcbb932ddb0128df78a71971c52838" );
9478 
9479  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9480  if( 0 == 0 )
9481  {
9482  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9483 
9484  if( strcmp( "FAIL", "FAIL" ) == 0 )
9485  {
9486  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9487  }
9488  else
9489  {
9490  hexify( dst_str, output, pt_len );
9491 
9492  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9493  }
9494  }
9495  }
9496  FCT_TEST_END();
9497 
9498 
9499  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024120_1)
9500  {
9501  unsigned char key_str[128];
9502  unsigned char src_str[128];
9503  unsigned char dst_str[257];
9504  unsigned char iv_str[128];
9505  unsigned char add_str[128];
9506  unsigned char tag_str[128];
9507  unsigned char output[128];
9508  gcm_context ctx;
9509  unsigned int key_len;
9510  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
9511  int ret;
9512 
9513  memset(key_str, 0x00, 128);
9514  memset(src_str, 0x00, 128);
9515  memset(dst_str, 0x00, 257);
9516  memset(iv_str, 0x00, 128);
9517  memset(add_str, 0x00, 128);
9518  memset(tag_str, 0x00, 128);
9519  memset(output, 0x00, 128);
9520 
9521  key_len = unhexify( key_str, "9bf22885e7f13bcc63bb0a2ca90c20e5c86001f05edf85d8" );
9522  pt_len = unhexify( src_str, "" );
9523  iv_len = unhexify( iv_str, "99dec21f4781284722b5074ea567c171" );
9524  add_len = unhexify( add_str, "9f4176dacf26e27aa0e669cd4d44bca41f83468c70b54c745a601408a214bf876941ae2ae4d26929113f5de2e7d15a7bb656541292137bf2129fdc31f06f070e3cfaf0a7b30d93d8d3c76a981d75cd0ffa0bcacb34597d5be1a055c35eefeddc07ee098603e48ad88eb7a2ec19c1aefc5c7be9a237797397aa27590d5261f67a" );
9525  unhexify( tag_str, "18fd1feec5e3bbf0985312dd6100d1" );
9526 
9527  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9528  if( 0 == 0 )
9529  {
9530  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9531 
9532  if( strcmp( "FAIL", "FAIL" ) == 0 )
9533  {
9534  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9535  }
9536  else
9537  {
9538  hexify( dst_str, output, pt_len );
9539 
9540  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9541  }
9542  }
9543  }
9544  FCT_TEST_END();
9545 
9546 
9547  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024120_2)
9548  {
9549  unsigned char key_str[128];
9550  unsigned char src_str[128];
9551  unsigned char dst_str[257];
9552  unsigned char iv_str[128];
9553  unsigned char add_str[128];
9554  unsigned char tag_str[128];
9555  unsigned char output[128];
9556  gcm_context ctx;
9557  unsigned int key_len;
9558  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
9559  int ret;
9560 
9561  memset(key_str, 0x00, 128);
9562  memset(src_str, 0x00, 128);
9563  memset(dst_str, 0x00, 257);
9564  memset(iv_str, 0x00, 128);
9565  memset(add_str, 0x00, 128);
9566  memset(tag_str, 0x00, 128);
9567  memset(output, 0x00, 128);
9568 
9569  key_len = unhexify( key_str, "cfd75a9d3788d965895553ab5fb7a8ff0aa383b7594850a6" );
9570  pt_len = unhexify( src_str, "" );
9571  iv_len = unhexify( iv_str, "a6df69e5f77f4d99d5318c45c87451b2" );
9572  add_len = unhexify( add_str, "041aeb2fa0f7df027cd7709a992e041179d499f5dbccd389035bf7e514a38b5f8368379d2d7b5015d4fa6fadfd7c75abd2d855f5ea4220315fad2c2d435d910253bf76f252a21c57fe74f7247dac32f4276d793d30d48dd61d0e14a4b7f07a56c94d3799d04324dfb2b27a22a5077e280422d4f014f253d138e74c9ac3428a7b" );
9573  unhexify( tag_str, "fd78b9956e4e4522605db410f97e84" );
9574 
9575  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9576  if( 0 == 0 )
9577  {
9578  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9579 
9580  if( strcmp( "FAIL", "FAIL" ) == 0 )
9581  {
9582  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9583  }
9584  else
9585  {
9586  hexify( dst_str, output, pt_len );
9587 
9588  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9589  }
9590  }
9591  }
9592  FCT_TEST_END();
9593 
9594 
9595  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024112_0)
9596  {
9597  unsigned char key_str[128];
9598  unsigned char src_str[128];
9599  unsigned char dst_str[257];
9600  unsigned char iv_str[128];
9601  unsigned char add_str[128];
9602  unsigned char tag_str[128];
9603  unsigned char output[128];
9604  gcm_context ctx;
9605  unsigned int key_len;
9606  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
9607  int ret;
9608 
9609  memset(key_str, 0x00, 128);
9610  memset(src_str, 0x00, 128);
9611  memset(dst_str, 0x00, 257);
9612  memset(iv_str, 0x00, 128);
9613  memset(add_str, 0x00, 128);
9614  memset(tag_str, 0x00, 128);
9615  memset(output, 0x00, 128);
9616 
9617  key_len = unhexify( key_str, "b0b21ae138485591c6bef7b3d5a0aa0e9762c30a50e4bba2" );
9618  pt_len = unhexify( src_str, "" );
9619  iv_len = unhexify( iv_str, "56dc980e1cba1bc2e3b4a0733d7897ca" );
9620  add_len = unhexify( add_str, "a38458e5cc71f22f6f5880dc018c5777c0e6c8a1301e7d0300c02c976423c2b65f522db4a90401035346d855c892cbf27092c81b969e99cb2b6198e450a95c547bb0145652c9720aaf72a975e4cb5124b483a42f84b5cd022367802c5f167a7dfc885c1f983bb4525a88c8257df3067b6d36d2dbf6323df80c3eaeffc2d176a5" );
9621  unhexify( tag_str, "b11f5c0e8cb6fea1a170c9342437" );
9622 
9623  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9624  if( 0 == 0 )
9625  {
9626  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9627 
9628  if( strcmp( "FAIL", "" ) == 0 )
9629  {
9630  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9631  }
9632  else
9633  {
9634  hexify( dst_str, output, pt_len );
9635 
9636  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
9637  }
9638  }
9639  }
9640  FCT_TEST_END();
9641 
9642 
9643  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024112_1)
9644  {
9645  unsigned char key_str[128];
9646  unsigned char src_str[128];
9647  unsigned char dst_str[257];
9648  unsigned char iv_str[128];
9649  unsigned char add_str[128];
9650  unsigned char tag_str[128];
9651  unsigned char output[128];
9652  gcm_context ctx;
9653  unsigned int key_len;
9654  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
9655  int ret;
9656 
9657  memset(key_str, 0x00, 128);
9658  memset(src_str, 0x00, 128);
9659  memset(dst_str, 0x00, 257);
9660  memset(iv_str, 0x00, 128);
9661  memset(add_str, 0x00, 128);
9662  memset(tag_str, 0x00, 128);
9663  memset(output, 0x00, 128);
9664 
9665  key_len = unhexify( key_str, "8775665aba345b1c3e626128b5afa3d0da8f4d36b8cf1ca6" );
9666  pt_len = unhexify( src_str, "" );
9667  iv_len = unhexify( iv_str, "cd17f761670e1f104f8ea4fb0cec7166" );
9668  add_len = unhexify( add_str, "2ee08a51ceaca1dbbb3ee09b72f57427fd34bd95da5b4c0933cbb0fc2f7270cffd3476aa05deeb892a7e6a8a3407e61f8631d1a00e47d46efb918393ee5099df7d65c12ab8c9640bfcb3a6cce00c3243d0b3f316f0822cfeae05ee67b419393cc81846b60c42aeb5c53f0ede1280dc36aa8ef59addd10668dd61557ce760c544" );
9669  unhexify( tag_str, "6cdf60e62c91a6a944fa80da1854" );
9670 
9671  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9672  if( 0 == 0 )
9673  {
9674  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9675 
9676  if( strcmp( "FAIL", "" ) == 0 )
9677  {
9678  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9679  }
9680  else
9681  {
9682  hexify( dst_str, output, pt_len );
9683 
9684  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
9685  }
9686  }
9687  }
9688  FCT_TEST_END();
9689 
9690 
9691  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024112_2)
9692  {
9693  unsigned char key_str[128];
9694  unsigned char src_str[128];
9695  unsigned char dst_str[257];
9696  unsigned char iv_str[128];
9697  unsigned char add_str[128];
9698  unsigned char tag_str[128];
9699  unsigned char output[128];
9700  gcm_context ctx;
9701  unsigned int key_len;
9702  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
9703  int ret;
9704 
9705  memset(key_str, 0x00, 128);
9706  memset(src_str, 0x00, 128);
9707  memset(dst_str, 0x00, 257);
9708  memset(iv_str, 0x00, 128);
9709  memset(add_str, 0x00, 128);
9710  memset(tag_str, 0x00, 128);
9711  memset(output, 0x00, 128);
9712 
9713  key_len = unhexify( key_str, "cc9922299b47725952f06272168b728218d2443028d81597" );
9714  pt_len = unhexify( src_str, "" );
9715  iv_len = unhexify( iv_str, "9b2f1a40717afcdbb6a95d6e335c9e4d" );
9716  add_len = unhexify( add_str, "bcfca8420bc7b9df0290d8c1bcf4e3e66d3a4be1c947af82dd541336e44e2c4fa7c6b456980b174948de30b694232b03f8eb990f849b5f57762886b449671e4f0b5e7a173f12910393bdf5c162163584c774ad3bba39794767a4cc45f4a582d307503960454631cdf551e528a863f2e014b1fca4955a78bd545dec831e4d71c7" );
9717  unhexify( tag_str, "dd515e5a8b41ecc441443a749b31" );
9718 
9719  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9720  if( 0 == 0 )
9721  {
9722  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9723 
9724  if( strcmp( "FAIL", "" ) == 0 )
9725  {
9726  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9727  }
9728  else
9729  {
9730  hexify( dst_str, output, pt_len );
9731 
9732  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
9733  }
9734  }
9735  }
9736  FCT_TEST_END();
9737 
9738 
9739  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024104_0)
9740  {
9741  unsigned char key_str[128];
9742  unsigned char src_str[128];
9743  unsigned char dst_str[257];
9744  unsigned char iv_str[128];
9745  unsigned char add_str[128];
9746  unsigned char tag_str[128];
9747  unsigned char output[128];
9748  gcm_context ctx;
9749  unsigned int key_len;
9750  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
9751  int ret;
9752 
9753  memset(key_str, 0x00, 128);
9754  memset(src_str, 0x00, 128);
9755  memset(dst_str, 0x00, 257);
9756  memset(iv_str, 0x00, 128);
9757  memset(add_str, 0x00, 128);
9758  memset(tag_str, 0x00, 128);
9759  memset(output, 0x00, 128);
9760 
9761  key_len = unhexify( key_str, "5a27d718f21c5cbdc52a745b931bc77bd1afa8b1231f8815" );
9762  pt_len = unhexify( src_str, "" );
9763  iv_len = unhexify( iv_str, "59661051912fba45023aef4e6f9380a5" );
9764  add_len = unhexify( add_str, "2b7ce5cea81300ed23501493310f1316581ef8a50e37eaadd4bb5f527add6deb09e7dcc67652e44ac889b48726d8c0ae80e2b3a89dd34232eb1da32f7f4fcd5bf8e920d286db8604f23ab06eab3e6f99beb55fe3725107e9d67a491cdada1580717bbf64c28799c9ab67922da9194747f32fd84197070a86838d1c9ebae379b7" );
9765  unhexify( tag_str, "f33e8f42b58f45a0456f83a13e" );
9766 
9767  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9768  if( 0 == 0 )
9769  {
9770  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9771 
9772  if( strcmp( "FAIL", "FAIL" ) == 0 )
9773  {
9774  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9775  }
9776  else
9777  {
9778  hexify( dst_str, output, pt_len );
9779 
9780  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9781  }
9782  }
9783  }
9784  FCT_TEST_END();
9785 
9786 
9787  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024104_1)
9788  {
9789  unsigned char key_str[128];
9790  unsigned char src_str[128];
9791  unsigned char dst_str[257];
9792  unsigned char iv_str[128];
9793  unsigned char add_str[128];
9794  unsigned char tag_str[128];
9795  unsigned char output[128];
9796  gcm_context ctx;
9797  unsigned int key_len;
9798  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
9799  int ret;
9800 
9801  memset(key_str, 0x00, 128);
9802  memset(src_str, 0x00, 128);
9803  memset(dst_str, 0x00, 257);
9804  memset(iv_str, 0x00, 128);
9805  memset(add_str, 0x00, 128);
9806  memset(tag_str, 0x00, 128);
9807  memset(output, 0x00, 128);
9808 
9809  key_len = unhexify( key_str, "b83e933cf54ac58f8c7e5ed18e4ed2213059158ed9cb2c30" );
9810  pt_len = unhexify( src_str, "" );
9811  iv_len = unhexify( iv_str, "8710af55dd79da45a4b24f6e972bc60a" );
9812  add_len = unhexify( add_str, "b7a428bc68696cee06f2f8b43f63b47914e29f04a4a40c0eec6193a9a24bbe012d68bea5573382dd579beeb0565b0e0334cce6724997138b198fce8325f07069d6890ac4c052e127aa6e70a6248e6536d1d3c6ac60d8cd14d9a45200f6540305f882df5fca2cac48278f94fe502b5abe2992fa2719b0ce98b7ef1b5582e0151c" );
9813  unhexify( tag_str, "380128ad7f35be87a17c9590fa" );
9814 
9815  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9816  if( 0 == 0 )
9817  {
9818  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9819 
9820  if( strcmp( "FAIL", "FAIL" ) == 0 )
9821  {
9822  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9823  }
9824  else
9825  {
9826  hexify( dst_str, output, pt_len );
9827 
9828  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9829  }
9830  }
9831  }
9832  FCT_TEST_END();
9833 
9834 
9835  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024104_2)
9836  {
9837  unsigned char key_str[128];
9838  unsigned char src_str[128];
9839  unsigned char dst_str[257];
9840  unsigned char iv_str[128];
9841  unsigned char add_str[128];
9842  unsigned char tag_str[128];
9843  unsigned char output[128];
9844  gcm_context ctx;
9845  unsigned int key_len;
9846  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
9847  int ret;
9848 
9849  memset(key_str, 0x00, 128);
9850  memset(src_str, 0x00, 128);
9851  memset(dst_str, 0x00, 257);
9852  memset(iv_str, 0x00, 128);
9853  memset(add_str, 0x00, 128);
9854  memset(tag_str, 0x00, 128);
9855  memset(output, 0x00, 128);
9856 
9857  key_len = unhexify( key_str, "d2f85f92092385f15da43a086cff64c7448b4ee5a83ed72e" );
9858  pt_len = unhexify( src_str, "" );
9859  iv_len = unhexify( iv_str, "9026dfd09e4553cd51c4c13ce70830de" );
9860  add_len = unhexify( add_str, "3c8de64c14df73c1b470a9d8aa693af96e487d548d03a92ce59c0baec8576129945c722586a66f03deb5029cbda029fb22d355952c3dadfdede20b63f4221f27c8e5d710e2b335c2d9a9b7ca899597a03c41ee6508e40a6d74814441ac3acb64a20f48a61e8a18f4bbcbd3e7e59bb3cd2be405afd6ac80d47ce6496c4b9b294c" );
9861  unhexify( tag_str, "e9e5beea7d39c9250347a2a33d" );
9862 
9863  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9864  if( 0 == 0 )
9865  {
9866  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9867 
9868  if( strcmp( "FAIL", "" ) == 0 )
9869  {
9870  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9871  }
9872  else
9873  {
9874  hexify( dst_str, output, pt_len );
9875 
9876  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
9877  }
9878  }
9879  }
9880  FCT_TEST_END();
9881 
9882 
9883  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102496_0)
9884  {
9885  unsigned char key_str[128];
9886  unsigned char src_str[128];
9887  unsigned char dst_str[257];
9888  unsigned char iv_str[128];
9889  unsigned char add_str[128];
9890  unsigned char tag_str[128];
9891  unsigned char output[128];
9892  gcm_context ctx;
9893  unsigned int key_len;
9894  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
9895  int ret;
9896 
9897  memset(key_str, 0x00, 128);
9898  memset(src_str, 0x00, 128);
9899  memset(dst_str, 0x00, 257);
9900  memset(iv_str, 0x00, 128);
9901  memset(add_str, 0x00, 128);
9902  memset(tag_str, 0x00, 128);
9903  memset(output, 0x00, 128);
9904 
9905  key_len = unhexify( key_str, "de7df44ce007c99f7baad6a6955195f14e60999ed9818707" );
9906  pt_len = unhexify( src_str, "" );
9907  iv_len = unhexify( iv_str, "4d209e414965fe99636c1c6493bba3a3" );
9908  add_len = unhexify( add_str, "da3bc6bdd414a1e07e00981cf9199371192a1fb2eaae20f7091e5fe5368e26d61b981f7f1d29f1a9085ad2789d101155a980de98d961c093941502268adb70537ad9783e6c7d5157c939f59b8ad474c3d7fc1fcc91165cdf8dd9d6ec70d6400086d564b68ebead0d03ebd3aa66ded555692b8de0baf43bc0ddef42e3a9eb34ab" );
9909  unhexify( tag_str, "24483a57c20826a709b7d10a" );
9910 
9911  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9912  if( 0 == 0 )
9913  {
9914  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9915 
9916  if( strcmp( "FAIL", "FAIL" ) == 0 )
9917  {
9918  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9919  }
9920  else
9921  {
9922  hexify( dst_str, output, pt_len );
9923 
9924  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9925  }
9926  }
9927  }
9928  FCT_TEST_END();
9929 
9930 
9931  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102496_1)
9932  {
9933  unsigned char key_str[128];
9934  unsigned char src_str[128];
9935  unsigned char dst_str[257];
9936  unsigned char iv_str[128];
9937  unsigned char add_str[128];
9938  unsigned char tag_str[128];
9939  unsigned char output[128];
9940  gcm_context ctx;
9941  unsigned int key_len;
9942  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
9943  int ret;
9944 
9945  memset(key_str, 0x00, 128);
9946  memset(src_str, 0x00, 128);
9947  memset(dst_str, 0x00, 257);
9948  memset(iv_str, 0x00, 128);
9949  memset(add_str, 0x00, 128);
9950  memset(tag_str, 0x00, 128);
9951  memset(output, 0x00, 128);
9952 
9953  key_len = unhexify( key_str, "1dfa5ff20046c775b5e768c2bd9775066ae766345b7befc3" );
9954  pt_len = unhexify( src_str, "" );
9955  iv_len = unhexify( iv_str, "2d49409b869b8b9fc5b67767979ca8cd" );
9956  add_len = unhexify( add_str, "e35d34478b228bc903ea2423697e603cc077967d7cfb062e95bc11d89fbe0a1f1d4569f89b2a7047300c1f5131d91564ec9bce014d18ba605a1c1e4e15e3e5c18413b8b59cbb25ab8f088885225de1235c16c7d9a8d06a23cb0b38fd1d5c6c19617fe08fd6bf01c965ed593149a1c6295435e98463e4f03a511d1a7e82c11f01" );
9957  unhexify( tag_str, "23012503febbf26dc2d872dc" );
9958 
9959  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
9960  if( 0 == 0 )
9961  {
9962  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
9963 
9964  if( strcmp( "FAIL", "FAIL" ) == 0 )
9965  {
9966  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
9967  }
9968  else
9969  {
9970  hexify( dst_str, output, pt_len );
9971 
9972  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
9973  }
9974  }
9975  }
9976  FCT_TEST_END();
9977 
9978 
9979  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102496_2)
9980  {
9981  unsigned char key_str[128];
9982  unsigned char src_str[128];
9983  unsigned char dst_str[257];
9984  unsigned char iv_str[128];
9985  unsigned char add_str[128];
9986  unsigned char tag_str[128];
9987  unsigned char output[128];
9988  gcm_context ctx;
9989  unsigned int key_len;
9990  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
9991  int ret;
9992 
9993  memset(key_str, 0x00, 128);
9994  memset(src_str, 0x00, 128);
9995  memset(dst_str, 0x00, 257);
9996  memset(iv_str, 0x00, 128);
9997  memset(add_str, 0x00, 128);
9998  memset(tag_str, 0x00, 128);
9999  memset(output, 0x00, 128);
10000 
10001  key_len = unhexify( key_str, "2df3ee3a6484c48fdd0d37bab443228c7d873c984529dfb4" );
10002  pt_len = unhexify( src_str, "" );
10003  iv_len = unhexify( iv_str, "dc6aeb41415c115d66443fbd7acdfc8f" );
10004  add_len = unhexify( add_str, "eafc6007fafb461d3b151bdff459e56dd09b7b48b93ea730c85e5424f762b4a9080de44497a7c56dd7855628ffc61c7b4faeb7d6f413d464fe5ec6401f3028427ae3e62db3ff39cd0f5333a664d3505ff42caa8899b96a92ec01934d4b59556feb9055e8dfb81f55e60135345bfce3e4199bfcdb3ce42523e7d24be2a04cdb67" );
10005  unhexify( tag_str, "e8e80bf6e5c4a55e7964f455" );
10006 
10007  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10008  if( 0 == 0 )
10009  {
10010  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10011 
10012  if( strcmp( "FAIL", "FAIL" ) == 0 )
10013  {
10014  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10015  }
10016  else
10017  {
10018  hexify( dst_str, output, pt_len );
10019 
10020  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10021  }
10022  }
10023  }
10024  FCT_TEST_END();
10025 
10026 
10027  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102464_0)
10028  {
10029  unsigned char key_str[128];
10030  unsigned char src_str[128];
10031  unsigned char dst_str[257];
10032  unsigned char iv_str[128];
10033  unsigned char add_str[128];
10034  unsigned char tag_str[128];
10035  unsigned char output[128];
10036  gcm_context ctx;
10037  unsigned int key_len;
10038  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
10039  int ret;
10040 
10041  memset(key_str, 0x00, 128);
10042  memset(src_str, 0x00, 128);
10043  memset(dst_str, 0x00, 257);
10044  memset(iv_str, 0x00, 128);
10045  memset(add_str, 0x00, 128);
10046  memset(tag_str, 0x00, 128);
10047  memset(output, 0x00, 128);
10048 
10049  key_len = unhexify( key_str, "ce0787f65e6c24a1c444c35dcd38195197530aa20f1f6f3b" );
10050  pt_len = unhexify( src_str, "" );
10051  iv_len = unhexify( iv_str, "55300431b1eaac0375681d7821e1eb7a" );
10052  add_len = unhexify( add_str, "84a699a34a1e597061ef95e8ec3c21b592e9236ddb98c68d7e05f1e709937b48ec34a4b88d99708d133a2cc33f5cf6819d5e7b82888e49faa5d54147d36c9e486630aa68fef88d55537119db1d57df0402f56e219f7ece7b4bb5f996dbe1c664a75174c880a00b0f2a56e35d17b69c550921961505afabf4bfd66cf04dc596d1" );
10053  unhexify( tag_str, "74264163131d16ac" );
10054 
10055  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10056  if( 0 == 0 )
10057  {
10058  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10059 
10060  if( strcmp( "FAIL", "FAIL" ) == 0 )
10061  {
10062  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10063  }
10064  else
10065  {
10066  hexify( dst_str, output, pt_len );
10067 
10068  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10069  }
10070  }
10071  }
10072  FCT_TEST_END();
10073 
10074 
10075  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102464_1)
10076  {
10077  unsigned char key_str[128];
10078  unsigned char src_str[128];
10079  unsigned char dst_str[257];
10080  unsigned char iv_str[128];
10081  unsigned char add_str[128];
10082  unsigned char tag_str[128];
10083  unsigned char output[128];
10084  gcm_context ctx;
10085  unsigned int key_len;
10086  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
10087  int ret;
10088 
10089  memset(key_str, 0x00, 128);
10090  memset(src_str, 0x00, 128);
10091  memset(dst_str, 0x00, 257);
10092  memset(iv_str, 0x00, 128);
10093  memset(add_str, 0x00, 128);
10094  memset(tag_str, 0x00, 128);
10095  memset(output, 0x00, 128);
10096 
10097  key_len = unhexify( key_str, "3a15541b5857a668dc9899b2e198d2416e83bac13282ca46" );
10098  pt_len = unhexify( src_str, "" );
10099  iv_len = unhexify( iv_str, "89bf8ab0cea6f59616eeb9b314d7c333" );
10100  add_len = unhexify( add_str, "4d2843f34f9ea13a1ac521479457005178bcf8b2ebeaeb09097ea4471da9f6cc60a532bcda1c18cab822af541de3b87de606999e994ace3951f58a02de0d6620c9ae04549326da449a3e90364a17b90b6b17debc0f454bb0e7e98aef56a1caccf8c91614d1616db30fc8223dbcd8e77bf55d8253efe034fd66f7191e0303c52f" );
10101  unhexify( tag_str, "8f4877806daff10e" );
10102 
10103  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10104  if( 0 == 0 )
10105  {
10106  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10107 
10108  if( strcmp( "FAIL", "FAIL" ) == 0 )
10109  {
10110  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10111  }
10112  else
10113  {
10114  hexify( dst_str, output, pt_len );
10115 
10116  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10117  }
10118  }
10119  }
10120  FCT_TEST_END();
10121 
10122 
10123  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102464_2)
10124  {
10125  unsigned char key_str[128];
10126  unsigned char src_str[128];
10127  unsigned char dst_str[257];
10128  unsigned char iv_str[128];
10129  unsigned char add_str[128];
10130  unsigned char tag_str[128];
10131  unsigned char output[128];
10132  gcm_context ctx;
10133  unsigned int key_len;
10134  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
10135  int ret;
10136 
10137  memset(key_str, 0x00, 128);
10138  memset(src_str, 0x00, 128);
10139  memset(dst_str, 0x00, 257);
10140  memset(iv_str, 0x00, 128);
10141  memset(add_str, 0x00, 128);
10142  memset(tag_str, 0x00, 128);
10143  memset(output, 0x00, 128);
10144 
10145  key_len = unhexify( key_str, "b61cdfd19c136ee2acbe09b7993a4683a713427518f8e559" );
10146  pt_len = unhexify( src_str, "" );
10147  iv_len = unhexify( iv_str, "4066118061c904ed1e866d4f31d11234" );
10148  add_len = unhexify( add_str, "153c075ecdd184fd8a0fca25cae8f720201361ef84f3c638b148ca32c51d091a0e394236d0b51c1d2ee601914120c56dfea1289af470dbc9ef462ec5f974e455e6a83e215a2c8e27c0c5b5b45b662b7f58635a29866e8f76ab41ee628c12a24ab4d5f7954665c3e4a3a346739f20393fc5700ec79d2e3c2722c3fb3c77305337" );
10149  unhexify( tag_str, "4eff7227b42f9a7d" );
10150 
10151  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10152  if( 0 == 0 )
10153  {
10154  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10155 
10156  if( strcmp( "FAIL", "" ) == 0 )
10157  {
10158  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10159  }
10160  else
10161  {
10162  hexify( dst_str, output, pt_len );
10163 
10164  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
10165  }
10166  }
10167  }
10168  FCT_TEST_END();
10169 
10170 
10171  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102432_0)
10172  {
10173  unsigned char key_str[128];
10174  unsigned char src_str[128];
10175  unsigned char dst_str[257];
10176  unsigned char iv_str[128];
10177  unsigned char add_str[128];
10178  unsigned char tag_str[128];
10179  unsigned char output[128];
10180  gcm_context ctx;
10181  unsigned int key_len;
10182  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
10183  int ret;
10184 
10185  memset(key_str, 0x00, 128);
10186  memset(src_str, 0x00, 128);
10187  memset(dst_str, 0x00, 257);
10188  memset(iv_str, 0x00, 128);
10189  memset(add_str, 0x00, 128);
10190  memset(tag_str, 0x00, 128);
10191  memset(output, 0x00, 128);
10192 
10193  key_len = unhexify( key_str, "ce175a7df7e429fcc233540e6b8524323e91f40f592ba144" );
10194  pt_len = unhexify( src_str, "" );
10195  iv_len = unhexify( iv_str, "c34484b4857b93e309df8e1a0e1ec9a3" );
10196  add_len = unhexify( add_str, "ce8d8775f047b543a6cc0d9ef9bc0db5ac5d610dc3ff6e12e0ad7cd3a399ebb762331e3c1101a189b3433a7ff4cd880a0639d2581b71e398dd982f55a11bf0f4e6ee95bacd897e8ec34649e1c256ee6ccecb33e36c76927cc5124bc2962713ad44cbd435ae3c1143796d3037fa1d659e5dad7ebf3c8cbdb5b619113d7ce8c483" );
10197  unhexify( tag_str, "ff355f10" );
10198 
10199  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10200  if( 0 == 0 )
10201  {
10202  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10203 
10204  if( strcmp( "FAIL", "" ) == 0 )
10205  {
10206  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10207  }
10208  else
10209  {
10210  hexify( dst_str, output, pt_len );
10211 
10212  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
10213  }
10214  }
10215  }
10216  FCT_TEST_END();
10217 
10218 
10219  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102432_1)
10220  {
10221  unsigned char key_str[128];
10222  unsigned char src_str[128];
10223  unsigned char dst_str[257];
10224  unsigned char iv_str[128];
10225  unsigned char add_str[128];
10226  unsigned char tag_str[128];
10227  unsigned char output[128];
10228  gcm_context ctx;
10229  unsigned int key_len;
10230  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
10231  int ret;
10232 
10233  memset(key_str, 0x00, 128);
10234  memset(src_str, 0x00, 128);
10235  memset(dst_str, 0x00, 257);
10236  memset(iv_str, 0x00, 128);
10237  memset(add_str, 0x00, 128);
10238  memset(tag_str, 0x00, 128);
10239  memset(output, 0x00, 128);
10240 
10241  key_len = unhexify( key_str, "5f659ed236ba60494e9bf1ee2cb40edcf3f25a2bac2e5bc5" );
10242  pt_len = unhexify( src_str, "" );
10243  iv_len = unhexify( iv_str, "ad49f12f202320255406c2f40e55b034" );
10244  add_len = unhexify( add_str, "6da62892f436dfe9790e72d26f4858ca156d1d655c9cc4336fcf282b0f3f0b201e47f799c3019109af89ef5fd48a4811980930e82cd95f86b1995d977c847bbb06ecdcc98b1aae100b23c9c2f0dcf317a1fb36f14e90e396e6c0c594bcc0dc5f3ebf86ce7ecd4b06d1c43202734d53f55751a6e6bbda982104102af240def4eb" );
10245  unhexify( tag_str, "cb4d8c1d" );
10246 
10247  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10248  if( 0 == 0 )
10249  {
10250  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10251 
10252  if( strcmp( "FAIL", "" ) == 0 )
10253  {
10254  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10255  }
10256  else
10257  {
10258  hexify( dst_str, output, pt_len );
10259 
10260  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
10261  }
10262  }
10263  }
10264  FCT_TEST_END();
10265 
10266 
10267  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102432_2)
10268  {
10269  unsigned char key_str[128];
10270  unsigned char src_str[128];
10271  unsigned char dst_str[257];
10272  unsigned char iv_str[128];
10273  unsigned char add_str[128];
10274  unsigned char tag_str[128];
10275  unsigned char output[128];
10276  gcm_context ctx;
10277  unsigned int key_len;
10278  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
10279  int ret;
10280 
10281  memset(key_str, 0x00, 128);
10282  memset(src_str, 0x00, 128);
10283  memset(dst_str, 0x00, 257);
10284  memset(iv_str, 0x00, 128);
10285  memset(add_str, 0x00, 128);
10286  memset(tag_str, 0x00, 128);
10287  memset(output, 0x00, 128);
10288 
10289  key_len = unhexify( key_str, "a73f318b1e298ba4ac0ab2aed74f73543b1017cccbd1b240" );
10290  pt_len = unhexify( src_str, "" );
10291  iv_len = unhexify( iv_str, "abe33b7e8d88bd30deb96d1e90c4e951" );
10292  add_len = unhexify( add_str, "6de616b000047b14b6759015183dd753c61499c0e665d06a89e4fb0cd0dd3064ff8651582e901ef5d0cdf3344c29c70c3aabc2aaf83cb3f284c6fe4104906d389b027e7d9ca60d010f06ef8cd9e55db2483d06552ddbe3fc43b24c55085cd998eae3edec36673445bf626e933c15b6af08ea21cbace4720b0b68fe1a374877d5" );
10293  unhexify( tag_str, "4a28ec97" );
10294 
10295  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10296  if( 0 == 0 )
10297  {
10298  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10299 
10300  if( strcmp( "FAIL", "FAIL" ) == 0 )
10301  {
10302  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10303  }
10304  else
10305  {
10306  hexify( dst_str, output, pt_len );
10307 
10308  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10309  }
10310  }
10311  }
10312  FCT_TEST_END();
10313 
10314 
10315  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240128_0)
10316  {
10317  unsigned char key_str[128];
10318  unsigned char src_str[128];
10319  unsigned char dst_str[257];
10320  unsigned char iv_str[128];
10321  unsigned char add_str[128];
10322  unsigned char tag_str[128];
10323  unsigned char output[128];
10324  gcm_context ctx;
10325  unsigned int key_len;
10326  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
10327  int ret;
10328 
10329  memset(key_str, 0x00, 128);
10330  memset(src_str, 0x00, 128);
10331  memset(dst_str, 0x00, 257);
10332  memset(iv_str, 0x00, 128);
10333  memset(add_str, 0x00, 128);
10334  memset(tag_str, 0x00, 128);
10335  memset(output, 0x00, 128);
10336 
10337  key_len = unhexify( key_str, "73d5be74615bc5b627eedfb95746fb5f17cbf25b500a597f" );
10338  pt_len = unhexify( src_str, "fc40993eb8559e6b127315c03103ce31b70fc0e07a766d9eecf2e4e8d973faa4afd3053c9ebef0282c9e3d2289d21b6c339748273fa1edf6d6ef5c8f1e1e9301b250297092d9ac4f4843125ea7299d5370f7f49c258eac2a58cc9df14c162604ba0801728994dc82cb625981130c3ca8cdb3391658d4e034691e62ece0a6e407" );
10339  iv_len = unhexify( iv_str, "eb16ed8de81efde2915a901f557fba95" );
10340  add_len = unhexify( add_str, "" );
10341  unhexify( tag_str, "804056dca9f102c4a13a930c81d77eca" );
10342 
10343  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10344  if( 0 == 0 )
10345  {
10346  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10347 
10348  if( strcmp( "FAIL", "FAIL" ) == 0 )
10349  {
10350  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10351  }
10352  else
10353  {
10354  hexify( dst_str, output, pt_len );
10355 
10356  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10357  }
10358  }
10359  }
10360  FCT_TEST_END();
10361 
10362 
10363  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240128_1)
10364  {
10365  unsigned char key_str[128];
10366  unsigned char src_str[128];
10367  unsigned char dst_str[257];
10368  unsigned char iv_str[128];
10369  unsigned char add_str[128];
10370  unsigned char tag_str[128];
10371  unsigned char output[128];
10372  gcm_context ctx;
10373  unsigned int key_len;
10374  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
10375  int ret;
10376 
10377  memset(key_str, 0x00, 128);
10378  memset(src_str, 0x00, 128);
10379  memset(dst_str, 0x00, 257);
10380  memset(iv_str, 0x00, 128);
10381  memset(add_str, 0x00, 128);
10382  memset(tag_str, 0x00, 128);
10383  memset(output, 0x00, 128);
10384 
10385  key_len = unhexify( key_str, "a249135c9f2f5a8b1af66442a4d4e101771a918ef8acee05" );
10386  pt_len = unhexify( src_str, "c62b39b937edbdc9b644321d5d284e62eaa4154010c7a3208c1ef4706fba90223da04b2f686a28b975eff17386598ba77e212855692f384782c1f3c00be011e466e145f6f8b65c458e41409e01a019b290773992e19334ffaca544e28fc9044a5e86bcd2fa5ad2e76f2be3f014d8c387456a8fcfded3ae4d1194d0e3e53a2031" );
10387  iv_len = unhexify( iv_str, "80b6e48fe4a3b08d40c1636b25dfd2c4" );
10388  add_len = unhexify( add_str, "" );
10389  unhexify( tag_str, "951c1c89b6d95661630d739dd9120a73" );
10390 
10391  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10392  if( 0 == 0 )
10393  {
10394  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10395 
10396  if( strcmp( "FAIL", "b865f8dd64a6f51a500bcfc8cadbc9e9f5d54d2d27d815ecfe3d5731e1b230c587b46958c6187e41b52ff187a14d26aa41c5f9909a3b77859429232e5bd6c6dc22cf5590402476d033a32682e8ab8dc7ed0b089c5ab20ab9a8c5d6a3be9ea7aa56c9d3ab08de4a4a019abb447db448062f16a533d416951a8ff6f13ed5608f77" ) == 0 )
10397  {
10398  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10399  }
10400  else
10401  {
10402  hexify( dst_str, output, pt_len );
10403 
10404  fct_chk( strcmp( (char *) dst_str, "b865f8dd64a6f51a500bcfc8cadbc9e9f5d54d2d27d815ecfe3d5731e1b230c587b46958c6187e41b52ff187a14d26aa41c5f9909a3b77859429232e5bd6c6dc22cf5590402476d033a32682e8ab8dc7ed0b089c5ab20ab9a8c5d6a3be9ea7aa56c9d3ab08de4a4a019abb447db448062f16a533d416951a8ff6f13ed5608f77" ) == 0 );
10405  }
10406  }
10407  }
10408  FCT_TEST_END();
10409 
10410 
10411  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240128_2)
10412  {
10413  unsigned char key_str[128];
10414  unsigned char src_str[128];
10415  unsigned char dst_str[257];
10416  unsigned char iv_str[128];
10417  unsigned char add_str[128];
10418  unsigned char tag_str[128];
10419  unsigned char output[128];
10420  gcm_context ctx;
10421  unsigned int key_len;
10422  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
10423  int ret;
10424 
10425  memset(key_str, 0x00, 128);
10426  memset(src_str, 0x00, 128);
10427  memset(dst_str, 0x00, 257);
10428  memset(iv_str, 0x00, 128);
10429  memset(add_str, 0x00, 128);
10430  memset(tag_str, 0x00, 128);
10431  memset(output, 0x00, 128);
10432 
10433  key_len = unhexify( key_str, "fa832a4b37dcb3c0879a771bb8ae734f0d88b9be497797a8" );
10434  pt_len = unhexify( src_str, "0f1105f9ec24121232b60b6ef3c3e8ca9eec1a3d7625004b857d1d77f292b6ec065d92f5bb97e0dc2fdfdf823a5db275109a9472690caea04730e4bd732c33548718e9f7658bbf3e30b8d07790cd540c5754486ed8e4d6920cefaeb1c182c4d67ebed0d205ba0bd9441a599d55e45094b380f3478bcfca9646a0d7aa18d08e52" );
10435  iv_len = unhexify( iv_str, "70835abab9f945c84ef4e97cdcf2a694" );
10436  add_len = unhexify( add_str, "" );
10437  unhexify( tag_str, "a459be0b349f6e8392c2a86edd8a9da5" );
10438 
10439  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10440  if( 0 == 0 )
10441  {
10442  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10443 
10444  if( strcmp( "FAIL", "FAIL" ) == 0 )
10445  {
10446  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10447  }
10448  else
10449  {
10450  hexify( dst_str, output, pt_len );
10451 
10452  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10453  }
10454  }
10455  }
10456  FCT_TEST_END();
10457 
10458 
10459  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240120_0)
10460  {
10461  unsigned char key_str[128];
10462  unsigned char src_str[128];
10463  unsigned char dst_str[257];
10464  unsigned char iv_str[128];
10465  unsigned char add_str[128];
10466  unsigned char tag_str[128];
10467  unsigned char output[128];
10468  gcm_context ctx;
10469  unsigned int key_len;
10470  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
10471  int ret;
10472 
10473  memset(key_str, 0x00, 128);
10474  memset(src_str, 0x00, 128);
10475  memset(dst_str, 0x00, 257);
10476  memset(iv_str, 0x00, 128);
10477  memset(add_str, 0x00, 128);
10478  memset(tag_str, 0x00, 128);
10479  memset(output, 0x00, 128);
10480 
10481  key_len = unhexify( key_str, "dda216287910d1f5c0a312f63c243612388bc510cb76c5ba" );
10482  pt_len = unhexify( src_str, "d6617d583344d4fe472099d2a688297857215a3e31b47d1bf355ccfe9cf2398a3eba362c670c88f8c7162903275dfd4761d095900bd97eba72200d4045d72bd239bda156829c36b38b1ff5e4230125e5695f623e129829721e889da235bb7d4b9da07cce8c3ceb96964fd2f9dd1ff0997e1a3e253a688ceb1bfec76a7c567266" );
10483  iv_len = unhexify( iv_str, "7f770140df5b8678bc9c4b962b8c9034" );
10484  add_len = unhexify( add_str, "" );
10485  unhexify( tag_str, "9823e3242b3f890c6a456f1837e039" );
10486 
10487  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10488  if( 0 == 0 )
10489  {
10490  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10491 
10492  if( strcmp( "FAIL", "b4910277224025f58a5d0f37385b03fcd488dfef7580eb5c270c10bd7a6f6d9c7ddc2d1368d68d4e04f90e3df029ed028432a09f710be1610b2a75bd05f31bae83920573929573affd0eb03c63e0cec7a027deab792f43ee6307fd3c5078d43d5b1407ac023824d41c9437d66eeec172488f28d700aa4b54931aad7cd458456f" ) == 0 )
10493  {
10494  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10495  }
10496  else
10497  {
10498  hexify( dst_str, output, pt_len );
10499 
10500  fct_chk( strcmp( (char *) dst_str, "b4910277224025f58a5d0f37385b03fcd488dfef7580eb5c270c10bd7a6f6d9c7ddc2d1368d68d4e04f90e3df029ed028432a09f710be1610b2a75bd05f31bae83920573929573affd0eb03c63e0cec7a027deab792f43ee6307fd3c5078d43d5b1407ac023824d41c9437d66eeec172488f28d700aa4b54931aad7cd458456f" ) == 0 );
10501  }
10502  }
10503  }
10504  FCT_TEST_END();
10505 
10506 
10507  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240120_1)
10508  {
10509  unsigned char key_str[128];
10510  unsigned char src_str[128];
10511  unsigned char dst_str[257];
10512  unsigned char iv_str[128];
10513  unsigned char add_str[128];
10514  unsigned char tag_str[128];
10515  unsigned char output[128];
10516  gcm_context ctx;
10517  unsigned int key_len;
10518  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
10519  int ret;
10520 
10521  memset(key_str, 0x00, 128);
10522  memset(src_str, 0x00, 128);
10523  memset(dst_str, 0x00, 257);
10524  memset(iv_str, 0x00, 128);
10525  memset(add_str, 0x00, 128);
10526  memset(tag_str, 0x00, 128);
10527  memset(output, 0x00, 128);
10528 
10529  key_len = unhexify( key_str, "c5afa1e61d4594b1c2fa637f64f18dd557e4df3255b47f24" );
10530  pt_len = unhexify( src_str, "5c772cdf19571cd51d71fc166d33a0b892fbca4eae36ab0ac94e6164d51acb2d4e60d4f3a19c3757a93960e7fd90b9a6cdf98bdf259b370ed6c7ef8cb96dba7e3a875e6e7fe6abc76aabad30c8743b3e47c8de5d604c748eeb16806c2e75180a96af7741904eca61769d39e943eb4c4c25f2afd68e9472043de2bb03e9edae20" );
10531  iv_len = unhexify( iv_str, "151fd3ba32f5bde72adce6291bcf63ea" );
10532  add_len = unhexify( add_str, "" );
10533  unhexify( tag_str, "f0626cc07f2ed1a7570386a4110fc1" );
10534 
10535  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10536  if( 0 == 0 )
10537  {
10538  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10539 
10540  if( strcmp( "FAIL", "FAIL" ) == 0 )
10541  {
10542  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10543  }
10544  else
10545  {
10546  hexify( dst_str, output, pt_len );
10547 
10548  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10549  }
10550  }
10551  }
10552  FCT_TEST_END();
10553 
10554 
10555  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240120_2)
10556  {
10557  unsigned char key_str[128];
10558  unsigned char src_str[128];
10559  unsigned char dst_str[257];
10560  unsigned char iv_str[128];
10561  unsigned char add_str[128];
10562  unsigned char tag_str[128];
10563  unsigned char output[128];
10564  gcm_context ctx;
10565  unsigned int key_len;
10566  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
10567  int ret;
10568 
10569  memset(key_str, 0x00, 128);
10570  memset(src_str, 0x00, 128);
10571  memset(dst_str, 0x00, 257);
10572  memset(iv_str, 0x00, 128);
10573  memset(add_str, 0x00, 128);
10574  memset(tag_str, 0x00, 128);
10575  memset(output, 0x00, 128);
10576 
10577  key_len = unhexify( key_str, "febd4ff0fedd9f16bccb62380d59cd41b8eff1834347d8fa" );
10578  pt_len = unhexify( src_str, "dc971c8f65ece2ea4130afd4db38fc657c085ea19c76fef50f5bd0f8dd364cc22471c2fa36be8cde78529f58a78888e9de10961760a01af005e42fc5b03e6f64962e6b18eaedea979d33d1b06e2038b1aad8993e5b20cae6cc93f3f7cf2ad658fbba633d74f21a2003dded5f5dda3b46ed7424845c11bab439fbb987f0be09f8" );
10579  iv_len = unhexify( iv_str, "743699d3759781e82a3d21c7cd7991c8" );
10580  add_len = unhexify( add_str, "" );
10581  unhexify( tag_str, "1da347f9b6341049e63140395ad445" );
10582 
10583  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10584  if( 0 == 0 )
10585  {
10586  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10587 
10588  if( strcmp( "FAIL", "FAIL" ) == 0 )
10589  {
10590  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10591  }
10592  else
10593  {
10594  hexify( dst_str, output, pt_len );
10595 
10596  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10597  }
10598  }
10599  }
10600  FCT_TEST_END();
10601 
10602 
10603  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240112_0)
10604  {
10605  unsigned char key_str[128];
10606  unsigned char src_str[128];
10607  unsigned char dst_str[257];
10608  unsigned char iv_str[128];
10609  unsigned char add_str[128];
10610  unsigned char tag_str[128];
10611  unsigned char output[128];
10612  gcm_context ctx;
10613  unsigned int key_len;
10614  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
10615  int ret;
10616 
10617  memset(key_str, 0x00, 128);
10618  memset(src_str, 0x00, 128);
10619  memset(dst_str, 0x00, 257);
10620  memset(iv_str, 0x00, 128);
10621  memset(add_str, 0x00, 128);
10622  memset(tag_str, 0x00, 128);
10623  memset(output, 0x00, 128);
10624 
10625  key_len = unhexify( key_str, "d280d079110c1c826cc77f490d807dd8d508eb579a160c49" );
10626  pt_len = unhexify( src_str, "a286d19610a990d64f3accd329fc005d468465a98cfa2f3606c6d0fbeb9732879bad3ca8094322a334a43155baed02d8e13a2fbf259d80066c6f418a1a74b23e0f6238f505b2b3dc906ffcb4910ce6c878b595bb4e5f8f3e2ede912b38dbafdf4659a93b056a1a67cb0ec1dbf00d93223f3b20b3f64a157105c5445b61628abf" );
10627  iv_len = unhexify( iv_str, "85b241d516b94759c9ef975f557bccea" );
10628  add_len = unhexify( add_str, "" );
10629  unhexify( tag_str, "bbf289df539f78c3a912b141da3a" );
10630 
10631  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10632  if( 0 == 0 )
10633  {
10634  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10635 
10636  if( strcmp( "FAIL", "b9286ab91645c20de040a805020fed53c612d493a8ce9c71649ae16bd50eab6fb7f3a9180e1651d5413aa542608d7ecbf9fc7378c0bef4d439bc35434b6cf803976b8783aecc83a91e95cea72c2a26a883b710252e0c2a6baa115739a0692c85f6d34ff06234fbdc79b8c4a8ea0a7056fb48c18f73aaf5084868abb0dfaa287d" ) == 0 )
10637  {
10638  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10639  }
10640  else
10641  {
10642  hexify( dst_str, output, pt_len );
10643 
10644  fct_chk( strcmp( (char *) dst_str, "b9286ab91645c20de040a805020fed53c612d493a8ce9c71649ae16bd50eab6fb7f3a9180e1651d5413aa542608d7ecbf9fc7378c0bef4d439bc35434b6cf803976b8783aecc83a91e95cea72c2a26a883b710252e0c2a6baa115739a0692c85f6d34ff06234fbdc79b8c4a8ea0a7056fb48c18f73aaf5084868abb0dfaa287d" ) == 0 );
10645  }
10646  }
10647  }
10648  FCT_TEST_END();
10649 
10650 
10651  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240112_1)
10652  {
10653  unsigned char key_str[128];
10654  unsigned char src_str[128];
10655  unsigned char dst_str[257];
10656  unsigned char iv_str[128];
10657  unsigned char add_str[128];
10658  unsigned char tag_str[128];
10659  unsigned char output[128];
10660  gcm_context ctx;
10661  unsigned int key_len;
10662  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
10663  int ret;
10664 
10665  memset(key_str, 0x00, 128);
10666  memset(src_str, 0x00, 128);
10667  memset(dst_str, 0x00, 257);
10668  memset(iv_str, 0x00, 128);
10669  memset(add_str, 0x00, 128);
10670  memset(tag_str, 0x00, 128);
10671  memset(output, 0x00, 128);
10672 
10673  key_len = unhexify( key_str, "5e80f87fa2156c62df7be2ad16c4890de5ee5868a684fcf9" );
10674  pt_len = unhexify( src_str, "c829073efd5c5150d2b7e2cdaeff979830d1aa983c747724ade6472c647a6e8e5033046e0359ea62fc26b4c95bccb3ac416fdf54e95815c35bf86d3fdd7856abbb618fe8fcd35a9295114926a0c9df92317d44ba1885a0c67c10b9ba24b8b2f3a464308c5578932247bf9c79d939aa3576376d2d6b4f14a378ab775531fe8abf" );
10675  iv_len = unhexify( iv_str, "9769f71c76b5b6c60462a845d2c123ad" );
10676  add_len = unhexify( add_str, "" );
10677  unhexify( tag_str, "394b6c631a69be3ed8c90770f3d4" );
10678 
10679  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10680  if( 0 == 0 )
10681  {
10682  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10683 
10684  if( strcmp( "FAIL", "f886bd92ca9d73a52e626b0c63a3daa138faaacf7809086d04f5c0c899362aa22e25d8659653b59c3103668461d9785bb425c6c1026ad9c924271cec9f27a9b341f708ca86f1d82a77aae88b25da9061b78b97276f3216720352629bd1a27ebf890da6f42d8c63d68342a93c382442d49dd4b62219504785cee89dffdc36f868" ) == 0 )
10685  {
10686  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10687  }
10688  else
10689  {
10690  hexify( dst_str, output, pt_len );
10691 
10692  fct_chk( strcmp( (char *) dst_str, "f886bd92ca9d73a52e626b0c63a3daa138faaacf7809086d04f5c0c899362aa22e25d8659653b59c3103668461d9785bb425c6c1026ad9c924271cec9f27a9b341f708ca86f1d82a77aae88b25da9061b78b97276f3216720352629bd1a27ebf890da6f42d8c63d68342a93c382442d49dd4b62219504785cee89dffdc36f868" ) == 0 );
10693  }
10694  }
10695  }
10696  FCT_TEST_END();
10697 
10698 
10699  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240112_2)
10700  {
10701  unsigned char key_str[128];
10702  unsigned char src_str[128];
10703  unsigned char dst_str[257];
10704  unsigned char iv_str[128];
10705  unsigned char add_str[128];
10706  unsigned char tag_str[128];
10707  unsigned char output[128];
10708  gcm_context ctx;
10709  unsigned int key_len;
10710  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
10711  int ret;
10712 
10713  memset(key_str, 0x00, 128);
10714  memset(src_str, 0x00, 128);
10715  memset(dst_str, 0x00, 257);
10716  memset(iv_str, 0x00, 128);
10717  memset(add_str, 0x00, 128);
10718  memset(tag_str, 0x00, 128);
10719  memset(output, 0x00, 128);
10720 
10721  key_len = unhexify( key_str, "d8a7b99e53f5e5b197364d4516cace4b928de50e571315e3" );
10722  pt_len = unhexify( src_str, "d0db0ac5e14bf03729125f3137d4854b4d8ce2d264f8646da17402bdad7034c0d84d7a80f107eb202aeadbfdf063904ae9793c6ae91ee8bcc0fc0674d8111f6aea6607633f92e4be3cfbb64418101db8b0a9225c83e60ffcf7a7f71f77149a13f8c5227cd92855241e11ee363062a893a76ac282fb47b523b306cd8235cd81c2" );
10723  iv_len = unhexify( iv_str, "4b12c6701534098e23e1b4659f684d6f" );
10724  add_len = unhexify( add_str, "" );
10725  unhexify( tag_str, "729b31c65d8699c93d741caac8e3" );
10726 
10727  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10728  if( 0 == 0 )
10729  {
10730  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10731 
10732  if( strcmp( "FAIL", "FAIL" ) == 0 )
10733  {
10734  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10735  }
10736  else
10737  {
10738  hexify( dst_str, output, pt_len );
10739 
10740  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10741  }
10742  }
10743  }
10744  FCT_TEST_END();
10745 
10746 
10747  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240104_0)
10748  {
10749  unsigned char key_str[128];
10750  unsigned char src_str[128];
10751  unsigned char dst_str[257];
10752  unsigned char iv_str[128];
10753  unsigned char add_str[128];
10754  unsigned char tag_str[128];
10755  unsigned char output[128];
10756  gcm_context ctx;
10757  unsigned int key_len;
10758  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
10759  int ret;
10760 
10761  memset(key_str, 0x00, 128);
10762  memset(src_str, 0x00, 128);
10763  memset(dst_str, 0x00, 257);
10764  memset(iv_str, 0x00, 128);
10765  memset(add_str, 0x00, 128);
10766  memset(tag_str, 0x00, 128);
10767  memset(output, 0x00, 128);
10768 
10769  key_len = unhexify( key_str, "c874b427b7181b0c90b887147c36f242827149324fd5c945" );
10770  pt_len = unhexify( src_str, "bdd90190d587a564af022f06c8bd1a68735b6f18f04113fdcec24c6027aaf0271b183336fb713d247a173d9e095dae6e9badb0ab069712302875406f14320151fd43b90a3d6f35cc856636b1a6f98afc797cb5259567e2e9b7ce62d7b3370b5ee852722faf740edf815b3af460cdd7de90ca6ab6cd173844216c064b16ea3696" );
10771  iv_len = unhexify( iv_str, "4b8dda046a5b7c46abeeca2f2f9bcaf8" );
10772  add_len = unhexify( add_str, "" );
10773  unhexify( tag_str, "fe1e427bcb15ce026413a0da87" );
10774 
10775  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10776  if( 0 == 0 )
10777  {
10778  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10779 
10780  if( strcmp( "FAIL", "FAIL" ) == 0 )
10781  {
10782  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10783  }
10784  else
10785  {
10786  hexify( dst_str, output, pt_len );
10787 
10788  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10789  }
10790  }
10791  }
10792  FCT_TEST_END();
10793 
10794 
10795  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240104_1)
10796  {
10797  unsigned char key_str[128];
10798  unsigned char src_str[128];
10799  unsigned char dst_str[257];
10800  unsigned char iv_str[128];
10801  unsigned char add_str[128];
10802  unsigned char tag_str[128];
10803  unsigned char output[128];
10804  gcm_context ctx;
10805  unsigned int key_len;
10806  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
10807  int ret;
10808 
10809  memset(key_str, 0x00, 128);
10810  memset(src_str, 0x00, 128);
10811  memset(dst_str, 0x00, 257);
10812  memset(iv_str, 0x00, 128);
10813  memset(add_str, 0x00, 128);
10814  memset(tag_str, 0x00, 128);
10815  memset(output, 0x00, 128);
10816 
10817  key_len = unhexify( key_str, "56543cd6e2ebb1e3dc136a826bfc37eddb12f7a26430a1b4" );
10818  pt_len = unhexify( src_str, "d541dd3acec2da042e6ea26fb90ff9a3861191926423b6dc99c5110b3bf150b362017159d0b85ffea397106a0d8299ec22791cb06103cd44036eed0d6d9f953724fb003068b3c3d97da129c28d97f09e6300cbea06ba66f410ca61c3311ce334c55f077c37acb3b7129c481748f79c958bc3bbeb2d3ff445ad361ed4bbc79f0a" );
10819  iv_len = unhexify( iv_str, "927ce8a596ed28c85d9cb8e688a829e6" );
10820  add_len = unhexify( add_str, "" );
10821  unhexify( tag_str, "3a98f471112a8a646460e8efd0" );
10822 
10823  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10824  if( 0 == 0 )
10825  {
10826  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10827 
10828  if( strcmp( "FAIL", "a602d61e7a35cbe0e463119bb66fd4bb6c75d1fe0b211b9d6a0a6e9e84b0794282318f0d33ec053f2cfba1623e865681affeaf29f3da3113995e87d51a5ab4872bb05b5be8ef2b14dfc3df5a48cbc9b10853a708ee4886a7390e8e4d286740a0dd41c025c8d72eda3f73f3cec5c33d5e50b643afd7691213cccccc2c41b9bd7a" ) == 0 )
10829  {
10830  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10831  }
10832  else
10833  {
10834  hexify( dst_str, output, pt_len );
10835 
10836  fct_chk( strcmp( (char *) dst_str, "a602d61e7a35cbe0e463119bb66fd4bb6c75d1fe0b211b9d6a0a6e9e84b0794282318f0d33ec053f2cfba1623e865681affeaf29f3da3113995e87d51a5ab4872bb05b5be8ef2b14dfc3df5a48cbc9b10853a708ee4886a7390e8e4d286740a0dd41c025c8d72eda3f73f3cec5c33d5e50b643afd7691213cccccc2c41b9bd7a" ) == 0 );
10837  }
10838  }
10839  }
10840  FCT_TEST_END();
10841 
10842 
10843  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240104_2)
10844  {
10845  unsigned char key_str[128];
10846  unsigned char src_str[128];
10847  unsigned char dst_str[257];
10848  unsigned char iv_str[128];
10849  unsigned char add_str[128];
10850  unsigned char tag_str[128];
10851  unsigned char output[128];
10852  gcm_context ctx;
10853  unsigned int key_len;
10854  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
10855  int ret;
10856 
10857  memset(key_str, 0x00, 128);
10858  memset(src_str, 0x00, 128);
10859  memset(dst_str, 0x00, 257);
10860  memset(iv_str, 0x00, 128);
10861  memset(add_str, 0x00, 128);
10862  memset(tag_str, 0x00, 128);
10863  memset(output, 0x00, 128);
10864 
10865  key_len = unhexify( key_str, "caaf81cd380f3af7885ef0d6196a1688c9372c5850dc5b0b" );
10866  pt_len = unhexify( src_str, "6f269929b92c6281e00672eaec183f187b2ddecc11c9045319521d245b595ab154dd50f045a660c4d53ae07d1b7a7fd6b21da10976eb5ffcddda08c1e9075a3b4d785faa003b4dd243f379e0654740b466704d9173bc43292ae0e279a903a955ce33b299bf2842b3461f7c9a2bd311f3e87254b5413d372ec543d6efa237b95a" );
10867  iv_len = unhexify( iv_str, "508c55f1726896f5b9f0a7024fe2fad0" );
10868  add_len = unhexify( add_str, "" );
10869  unhexify( tag_str, "3b8026268caf599ee677ecfd70" );
10870 
10871  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10872  if( 0 == 0 )
10873  {
10874  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10875 
10876  if( strcmp( "FAIL", "c4a96fb08d7c2eebd17046172b98569bc2441929fc0d6876aa1f389b80c05e2ede74dc6f8c3896a2ccf518e1b375ee75e4967f7cca21fa81ee176f8fb8753381ce03b2df873897131adc62a0cbebf718c8e0bb8eeed3104535f17a9c706d178d95a1b232e9dac31f2d1bdb3a1b098f3056f0e3d18be36bd746675779c0f80a10" ) == 0 )
10877  {
10878  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10879  }
10880  else
10881  {
10882  hexify( dst_str, output, pt_len );
10883 
10884  fct_chk( strcmp( (char *) dst_str, "c4a96fb08d7c2eebd17046172b98569bc2441929fc0d6876aa1f389b80c05e2ede74dc6f8c3896a2ccf518e1b375ee75e4967f7cca21fa81ee176f8fb8753381ce03b2df873897131adc62a0cbebf718c8e0bb8eeed3104535f17a9c706d178d95a1b232e9dac31f2d1bdb3a1b098f3056f0e3d18be36bd746675779c0f80a10" ) == 0 );
10885  }
10886  }
10887  }
10888  FCT_TEST_END();
10889 
10890 
10891  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024096_0)
10892  {
10893  unsigned char key_str[128];
10894  unsigned char src_str[128];
10895  unsigned char dst_str[257];
10896  unsigned char iv_str[128];
10897  unsigned char add_str[128];
10898  unsigned char tag_str[128];
10899  unsigned char output[128];
10900  gcm_context ctx;
10901  unsigned int key_len;
10902  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
10903  int ret;
10904 
10905  memset(key_str, 0x00, 128);
10906  memset(src_str, 0x00, 128);
10907  memset(dst_str, 0x00, 257);
10908  memset(iv_str, 0x00, 128);
10909  memset(add_str, 0x00, 128);
10910  memset(tag_str, 0x00, 128);
10911  memset(output, 0x00, 128);
10912 
10913  key_len = unhexify( key_str, "2fc9d9ac8469cfc718add2b03a4d8c8dcc2eeca08e5ff7bc" );
10914  pt_len = unhexify( src_str, "bc84d8a962a9cfd179d242788473d980d177abd0af9edccb14c6dc41535439a1768978158eeed99466574ea820dbedea68c819ffd9f9915ca8392c2e03049d7198baeca1d3491fe2345e64c1012aff03985b86c831ad516d4f5eb538109fff25383c7b0fa6b940ae19b0987d8c3e4a37ccbbd2034633c1eb0df1e9ddf3a8239e" );
10915  iv_len = unhexify( iv_str, "b2a7c0d52fc60bacc3d1a94f33087095" );
10916  add_len = unhexify( add_str, "" );
10917  unhexify( tag_str, "0a7a36ec128d0deb60869893" );
10918 
10919  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10920  if( 0 == 0 )
10921  {
10922  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10923 
10924  if( strcmp( "FAIL", "fc3cd6486dfe944f7cb035787573a554f4fe010c15bd08d6b09f73066f6f272ff84474f3845337b6e429c947d419c511c2945ffb181492c5465940cef85077e8a6a272a07e310a2f3808f11be03d96162913c613d9c3f25c3893c2bd2a58a619a9757fd16cc20c1308f2140557330379f07dbfd8979b26b075977805f1885acc" ) == 0 )
10925  {
10926  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10927  }
10928  else
10929  {
10930  hexify( dst_str, output, pt_len );
10931 
10932  fct_chk( strcmp( (char *) dst_str, "fc3cd6486dfe944f7cb035787573a554f4fe010c15bd08d6b09f73066f6f272ff84474f3845337b6e429c947d419c511c2945ffb181492c5465940cef85077e8a6a272a07e310a2f3808f11be03d96162913c613d9c3f25c3893c2bd2a58a619a9757fd16cc20c1308f2140557330379f07dbfd8979b26b075977805f1885acc" ) == 0 );
10933  }
10934  }
10935  }
10936  FCT_TEST_END();
10937 
10938 
10939  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024096_1)
10940  {
10941  unsigned char key_str[128];
10942  unsigned char src_str[128];
10943  unsigned char dst_str[257];
10944  unsigned char iv_str[128];
10945  unsigned char add_str[128];
10946  unsigned char tag_str[128];
10947  unsigned char output[128];
10948  gcm_context ctx;
10949  unsigned int key_len;
10950  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
10951  int ret;
10952 
10953  memset(key_str, 0x00, 128);
10954  memset(src_str, 0x00, 128);
10955  memset(dst_str, 0x00, 257);
10956  memset(iv_str, 0x00, 128);
10957  memset(add_str, 0x00, 128);
10958  memset(tag_str, 0x00, 128);
10959  memset(output, 0x00, 128);
10960 
10961  key_len = unhexify( key_str, "81ff729efa4a9aa2eccc37c5f846235b53d3b93c79c709c8" );
10962  pt_len = unhexify( src_str, "3992ad29eeb97d17bd5c0f04d8589903ee23ccb2b1adc2992a48a2eb62c2644c0df53b4afe4ace60dc5ec249c0c083473ebac3323539a575c14fa74c8381d1ac90cb501240f96d1779b287f7d8ba8775281d453aae37c803185f2711d21f5c00eb45cad37587ed196d1633f1eb0b33abef337447d03ec09c0e3f7fd32e8c69f0" );
10963  iv_len = unhexify( iv_str, "1bd17f04d1dc2e447b41665952ad9031" );
10964  add_len = unhexify( add_str, "" );
10965  unhexify( tag_str, "01b0a815dc6da3e32851e1fb" );
10966 
10967  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
10968  if( 0 == 0 )
10969  {
10970  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
10971 
10972  if( strcmp( "FAIL", "FAIL" ) == 0 )
10973  {
10974  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
10975  }
10976  else
10977  {
10978  hexify( dst_str, output, pt_len );
10979 
10980  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
10981  }
10982  }
10983  }
10984  FCT_TEST_END();
10985 
10986 
10987  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024096_2)
10988  {
10989  unsigned char key_str[128];
10990  unsigned char src_str[128];
10991  unsigned char dst_str[257];
10992  unsigned char iv_str[128];
10993  unsigned char add_str[128];
10994  unsigned char tag_str[128];
10995  unsigned char output[128];
10996  gcm_context ctx;
10997  unsigned int key_len;
10998  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
10999  int ret;
11000 
11001  memset(key_str, 0x00, 128);
11002  memset(src_str, 0x00, 128);
11003  memset(dst_str, 0x00, 257);
11004  memset(iv_str, 0x00, 128);
11005  memset(add_str, 0x00, 128);
11006  memset(tag_str, 0x00, 128);
11007  memset(output, 0x00, 128);
11008 
11009  key_len = unhexify( key_str, "068500e8d4f8d4af9035cdaa8e005a648352e8f28bdafc8a" );
11010  pt_len = unhexify( src_str, "98e32428d9d21c4b60e690a2ce1cf70bee90df31302d1819b7d27fd577dd990f7ffe6ba5ef117caac718cc1880b4ca98f72db281c9609e189307302dc2866f20be3a545a565521368a6881e2642cba63b3cf4c8b5e5a8eabeb3e8b004618b8f77667c111e5402c5d7c66afd297c575ce5092e898d5831031d225cee668c186a1" );
11011  iv_len = unhexify( iv_str, "5ea9198b860679759357befdbb106b62" );
11012  add_len = unhexify( add_str, "" );
11013  unhexify( tag_str, "d58752f66b2cb9bb2bc388eb" );
11014 
11015  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11016  if( 0 == 0 )
11017  {
11018  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11019 
11020  if( strcmp( "FAIL", "2ef3a17fcdb154f60d5e80263b7301a8526d2de451ea49adb441aa2541986b868dab24027178f48759dbe874ae7aa7b27fb19461c6678a0ba84bbcd8567ba2412a55179e15e7c1a1392730ac392b59c51d48f8366d45b933880095800e1f36ff1ac00753f6363b0e854f494552f1f2efe028d969e6b1a8080149dd853aa6751e" ) == 0 )
11021  {
11022  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11023  }
11024  else
11025  {
11026  hexify( dst_str, output, pt_len );
11027 
11028  fct_chk( strcmp( (char *) dst_str, "2ef3a17fcdb154f60d5e80263b7301a8526d2de451ea49adb441aa2541986b868dab24027178f48759dbe874ae7aa7b27fb19461c6678a0ba84bbcd8567ba2412a55179e15e7c1a1392730ac392b59c51d48f8366d45b933880095800e1f36ff1ac00753f6363b0e854f494552f1f2efe028d969e6b1a8080149dd853aa6751e" ) == 0 );
11029  }
11030  }
11031  }
11032  FCT_TEST_END();
11033 
11034 
11035  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024064_0)
11036  {
11037  unsigned char key_str[128];
11038  unsigned char src_str[128];
11039  unsigned char dst_str[257];
11040  unsigned char iv_str[128];
11041  unsigned char add_str[128];
11042  unsigned char tag_str[128];
11043  unsigned char output[128];
11044  gcm_context ctx;
11045  unsigned int key_len;
11046  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
11047  int ret;
11048 
11049  memset(key_str, 0x00, 128);
11050  memset(src_str, 0x00, 128);
11051  memset(dst_str, 0x00, 257);
11052  memset(iv_str, 0x00, 128);
11053  memset(add_str, 0x00, 128);
11054  memset(tag_str, 0x00, 128);
11055  memset(output, 0x00, 128);
11056 
11057  key_len = unhexify( key_str, "7474d9b07739001b25baf6867254994e06e54c578508232f" );
11058  pt_len = unhexify( src_str, "1cbab2b6e4274caa80987072914f667b887198f7aaf4574608b91b5274f5afc3eb05a457554ff5d346d460f92c068bc626fd301d0bb15cb3726504b3d88ecd46a15077728ddc2b698a2e8c5ea5885fc534ac227b8f103d193f1977badf4f853a0931398da01f8019a9b1ff271b3a783ff0fae6f54db425af6e3a345ba7512cbf" );
11059  iv_len = unhexify( iv_str, "3ade6c92fe2dc575c136e3fbbba5c484" );
11060  add_len = unhexify( add_str, "" );
11061  unhexify( tag_str, "67c25240b8e39b63" );
11062 
11063  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11064  if( 0 == 0 )
11065  {
11066  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11067 
11068  if( strcmp( "FAIL", "FAIL" ) == 0 )
11069  {
11070  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11071  }
11072  else
11073  {
11074  hexify( dst_str, output, pt_len );
11075 
11076  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11077  }
11078  }
11079  }
11080  FCT_TEST_END();
11081 
11082 
11083  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024064_1)
11084  {
11085  unsigned char key_str[128];
11086  unsigned char src_str[128];
11087  unsigned char dst_str[257];
11088  unsigned char iv_str[128];
11089  unsigned char add_str[128];
11090  unsigned char tag_str[128];
11091  unsigned char output[128];
11092  gcm_context ctx;
11093  unsigned int key_len;
11094  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
11095  int ret;
11096 
11097  memset(key_str, 0x00, 128);
11098  memset(src_str, 0x00, 128);
11099  memset(dst_str, 0x00, 257);
11100  memset(iv_str, 0x00, 128);
11101  memset(add_str, 0x00, 128);
11102  memset(tag_str, 0x00, 128);
11103  memset(output, 0x00, 128);
11104 
11105  key_len = unhexify( key_str, "d50d4c7d442d8a92d0489a96e897d50dda6fbe47ca7713ee" );
11106  pt_len = unhexify( src_str, "b36b4caf1d47b0d10652824bd57b603ec1c16f4720ce7d43edde8af1b9737f61b68b882566e04da50136f27d9af4c4c57fff4c8465c8a85f0aeadc17e02709cc9ba818d9a272709e5fb65dd5612a5c5d700da399b3668a00041a51c23de616ea3f72093d85ecbfd9dd0b5d02b541fb605dcffe81e9f45a5c0c191cc0b92ac56d" );
11107  iv_len = unhexify( iv_str, "41b37c04ab8a80f5a8d9d82a3a444772" );
11108  add_len = unhexify( add_str, "" );
11109  unhexify( tag_str, "4ee54d280829e6ef" );
11110 
11111  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11112  if( 0 == 0 )
11113  {
11114  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11115 
11116  if( strcmp( "FAIL", "FAIL" ) == 0 )
11117  {
11118  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11119  }
11120  else
11121  {
11122  hexify( dst_str, output, pt_len );
11123 
11124  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11125  }
11126  }
11127  }
11128  FCT_TEST_END();
11129 
11130 
11131  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024064_2)
11132  {
11133  unsigned char key_str[128];
11134  unsigned char src_str[128];
11135  unsigned char dst_str[257];
11136  unsigned char iv_str[128];
11137  unsigned char add_str[128];
11138  unsigned char tag_str[128];
11139  unsigned char output[128];
11140  gcm_context ctx;
11141  unsigned int key_len;
11142  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
11143  int ret;
11144 
11145  memset(key_str, 0x00, 128);
11146  memset(src_str, 0x00, 128);
11147  memset(dst_str, 0x00, 257);
11148  memset(iv_str, 0x00, 128);
11149  memset(add_str, 0x00, 128);
11150  memset(tag_str, 0x00, 128);
11151  memset(output, 0x00, 128);
11152 
11153  key_len = unhexify( key_str, "38f3ec3ec775dac76ae484d5b6ca61c695c7beafba4606ca" );
11154  pt_len = unhexify( src_str, "49726b8cefc842a02f2d7bef099871f38257cc8ea096c9ac50baced6d940acb4e8baf932bec379a973a2c3a3bc49f60f7e9eef45eafdd15bda1dd1557f068e81226af503934eb96564d14c03f0f351974c8a54fb104fb07417fe79272e4b0c0072b9f89b770326562e4e1b14cad784a2cd1b4ae1dc43623ec451a1cae55f6f84" );
11155  iv_len = unhexify( iv_str, "9af53cf6891a749ab286f5c34238088a" );
11156  add_len = unhexify( add_str, "" );
11157  unhexify( tag_str, "6f6f344dd43b0d20" );
11158 
11159  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11160  if( 0 == 0 )
11161  {
11162  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11163 
11164  if( strcmp( "FAIL", "FAIL" ) == 0 )
11165  {
11166  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11167  }
11168  else
11169  {
11170  hexify( dst_str, output, pt_len );
11171 
11172  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11173  }
11174  }
11175  }
11176  FCT_TEST_END();
11177 
11178 
11179  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024032_0)
11180  {
11181  unsigned char key_str[128];
11182  unsigned char src_str[128];
11183  unsigned char dst_str[257];
11184  unsigned char iv_str[128];
11185  unsigned char add_str[128];
11186  unsigned char tag_str[128];
11187  unsigned char output[128];
11188  gcm_context ctx;
11189  unsigned int key_len;
11190  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
11191  int ret;
11192 
11193  memset(key_str, 0x00, 128);
11194  memset(src_str, 0x00, 128);
11195  memset(dst_str, 0x00, 257);
11196  memset(iv_str, 0x00, 128);
11197  memset(add_str, 0x00, 128);
11198  memset(tag_str, 0x00, 128);
11199  memset(output, 0x00, 128);
11200 
11201  key_len = unhexify( key_str, "6db4ef061513ef6690d57aef50d8011e0dd7eb4432d82374" );
11202  pt_len = unhexify( src_str, "b7f9206995bc97311855ee832e2b40c41ab2d1a40d9263683c95b14dcc51c74d2de7b6198f9d4766c659e7619fe2693a5b188fac464ccbd5e632c5fd248cedba4028a92de12ed91415077e94cfe7a60f117052dea8916dfe0a51d92c1c03927e93012dbacd29bbbc50ce537a8173348ca904ac86df55940e9394c2895a9fe563" );
11203  iv_len = unhexify( iv_str, "623df5a0922d1e8c883debb2e0e5e0b1" );
11204  add_len = unhexify( add_str, "" );
11205  unhexify( tag_str, "14f690d7" );
11206 
11207  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11208  if( 0 == 0 )
11209  {
11210  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11211 
11212  if( strcmp( "FAIL", "a6414daa9be693e7ebb32480a783c54292e57feef4abbb3636bebbc3074bfc608ad55896fe9bd5ab875e52a43f715b98f52c07fc9fa6194ea0cd8ed78404f251639069c5a313ccfc6b94fb1657153ff48f16f6e22b3c4a0b7f88e188c90176447fe27fa7ddc2bac3d2b7edecad5f7605093ac4280b38ae6a4c040d2d4d491b42" ) == 0 )
11213  {
11214  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11215  }
11216  else
11217  {
11218  hexify( dst_str, output, pt_len );
11219 
11220  fct_chk( strcmp( (char *) dst_str, "a6414daa9be693e7ebb32480a783c54292e57feef4abbb3636bebbc3074bfc608ad55896fe9bd5ab875e52a43f715b98f52c07fc9fa6194ea0cd8ed78404f251639069c5a313ccfc6b94fb1657153ff48f16f6e22b3c4a0b7f88e188c90176447fe27fa7ddc2bac3d2b7edecad5f7605093ac4280b38ae6a4c040d2d4d491b42" ) == 0 );
11221  }
11222  }
11223  }
11224  FCT_TEST_END();
11225 
11226 
11227  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024032_1)
11228  {
11229  unsigned char key_str[128];
11230  unsigned char src_str[128];
11231  unsigned char dst_str[257];
11232  unsigned char iv_str[128];
11233  unsigned char add_str[128];
11234  unsigned char tag_str[128];
11235  unsigned char output[128];
11236  gcm_context ctx;
11237  unsigned int key_len;
11238  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
11239  int ret;
11240 
11241  memset(key_str, 0x00, 128);
11242  memset(src_str, 0x00, 128);
11243  memset(dst_str, 0x00, 257);
11244  memset(iv_str, 0x00, 128);
11245  memset(add_str, 0x00, 128);
11246  memset(tag_str, 0x00, 128);
11247  memset(output, 0x00, 128);
11248 
11249  key_len = unhexify( key_str, "8901bec4d3c64071d8c30c720c093221e05efed71da280bf" );
11250  pt_len = unhexify( src_str, "7c447e700db7367260dffa42050e612eff062eb0c8a6b4fe34858800bcb8ec2f622cb5213767b5771433783e9b0fa617c9ffb7fde09845dafc16dfc0df61215c0ca1191eabf43293db6603d5285859de7ef3329f5e71201586fb0188f0840ed5b877043ca06039768c77ff8687c5cfc2fd013a0b8da48344c568fce6b39e2b19" );
11251  iv_len = unhexify( iv_str, "9265abe966cb83838d7fd9302938f49d" );
11252  add_len = unhexify( add_str, "" );
11253  unhexify( tag_str, "6f6c38bc" );
11254 
11255  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11256  if( 0 == 0 )
11257  {
11258  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11259 
11260  if( strcmp( "FAIL", "FAIL" ) == 0 )
11261  {
11262  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11263  }
11264  else
11265  {
11266  hexify( dst_str, output, pt_len );
11267 
11268  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11269  }
11270  }
11271  }
11272  FCT_TEST_END();
11273 
11274 
11275  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024032_2)
11276  {
11277  unsigned char key_str[128];
11278  unsigned char src_str[128];
11279  unsigned char dst_str[257];
11280  unsigned char iv_str[128];
11281  unsigned char add_str[128];
11282  unsigned char tag_str[128];
11283  unsigned char output[128];
11284  gcm_context ctx;
11285  unsigned int key_len;
11286  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
11287  int ret;
11288 
11289  memset(key_str, 0x00, 128);
11290  memset(src_str, 0x00, 128);
11291  memset(dst_str, 0x00, 257);
11292  memset(iv_str, 0x00, 128);
11293  memset(add_str, 0x00, 128);
11294  memset(tag_str, 0x00, 128);
11295  memset(output, 0x00, 128);
11296 
11297  key_len = unhexify( key_str, "2c57eb763f886154d3846cc333fc8ae8b3c7c9c3705f9872" );
11298  pt_len = unhexify( src_str, "9fe7d210221773ba4a163850bab290ba9b7bf5e825760ac940c290a1b40cd6dd5b9fb6385ae1a79d35ee7b355b34275857d5b847bef4ac7a58f6f0e9de68687807009f5dc26244935d7bcafc7aed18316ce6c375192d2a7bf0bee8a632fe4f412440292e39339b94b28281622842f88048be4640486f2b21a119658c294ce32e" );
11299  iv_len = unhexify( iv_str, "9b3781165e7ff113ecd1d83d1df2366d" );
11300  add_len = unhexify( add_str, "" );
11301  unhexify( tag_str, "62f32d4e" );
11302 
11303  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11304  if( 0 == 0 )
11305  {
11306  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11307 
11308  if( strcmp( "FAIL", "FAIL" ) == 0 )
11309  {
11310  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11311  }
11312  else
11313  {
11314  hexify( dst_str, output, pt_len );
11315 
11316  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11317  }
11318  }
11319  }
11320  FCT_TEST_END();
11321 
11322 
11323  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024128_0)
11324  {
11325  unsigned char key_str[128];
11326  unsigned char src_str[128];
11327  unsigned char dst_str[257];
11328  unsigned char iv_str[128];
11329  unsigned char add_str[128];
11330  unsigned char tag_str[128];
11331  unsigned char output[128];
11332  gcm_context ctx;
11333  unsigned int key_len;
11334  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
11335  int ret;
11336 
11337  memset(key_str, 0x00, 128);
11338  memset(src_str, 0x00, 128);
11339  memset(dst_str, 0x00, 257);
11340  memset(iv_str, 0x00, 128);
11341  memset(add_str, 0x00, 128);
11342  memset(tag_str, 0x00, 128);
11343  memset(output, 0x00, 128);
11344 
11345  key_len = unhexify( key_str, "307d31a594e54f673bea2f977835670aca4f3d45c9c376cc" );
11346  pt_len = unhexify( src_str, "d7385a7bd0cb76e1e242fa547c474370bcc7cc7cf3e3fa37b00fe08a56383ca31d023d8c493f6d42e482b0f32e4f244dd100ea08eee6535e5bb8d27f76dbb7eead6ba8e031ccd0eaeb649edee92aeaf0f027d59efd4e39b1f34b15ceb8b592ee0f171b1773b308c0e747790b0e6ace90fc661caa5f942bdc197067f28fbe87d1" );
11347  iv_len = unhexify( iv_str, "0bdaa353c4904d32432926f27534c73c" );
11348  add_len = unhexify( add_str, "aa39f04559ccc2cae3d563dda831fb238b2582cb2c2bb28cff20cc20200724c8771b9805ef7464b8fc06c7b8060c6920fd2779fbc807c2292c8c1f88f8088755609a1732ff8c0b06606452b970c79997b985889404fd907c4668a0bcc11ba617175f4525523494a244da60b238468c863055f04db20ea489adf545d56c0a71d8" );
11349  unhexify( tag_str, "2ddda790aae2ca427f5fb032c29673e6" );
11350 
11351  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11352  if( 0 == 0 )
11353  {
11354  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11355 
11356  if( strcmp( "FAIL", "0b92262759897f4bd5624a891187eba6040d79322a2a5a60fb75c6c6a5badd117abe40c6d963931bbc72dca1a1bf1f5388030fe323b3b24bd408334b95908177fb59af57c5cc6b31825bc7097eec7fec19f9cdb41c0264fd22f71893bcf881c1510feb8057e64880f1ea2df8dc60bb300fd06b0a582f7be534e522caadc4a2c7" ) == 0 )
11357  {
11358  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11359  }
11360  else
11361  {
11362  hexify( dst_str, output, pt_len );
11363 
11364  fct_chk( strcmp( (char *) dst_str, "0b92262759897f4bd5624a891187eba6040d79322a2a5a60fb75c6c6a5badd117abe40c6d963931bbc72dca1a1bf1f5388030fe323b3b24bd408334b95908177fb59af57c5cc6b31825bc7097eec7fec19f9cdb41c0264fd22f71893bcf881c1510feb8057e64880f1ea2df8dc60bb300fd06b0a582f7be534e522caadc4a2c7" ) == 0 );
11365  }
11366  }
11367  }
11368  FCT_TEST_END();
11369 
11370 
11371  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024128_1)
11372  {
11373  unsigned char key_str[128];
11374  unsigned char src_str[128];
11375  unsigned char dst_str[257];
11376  unsigned char iv_str[128];
11377  unsigned char add_str[128];
11378  unsigned char tag_str[128];
11379  unsigned char output[128];
11380  gcm_context ctx;
11381  unsigned int key_len;
11382  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
11383  int ret;
11384 
11385  memset(key_str, 0x00, 128);
11386  memset(src_str, 0x00, 128);
11387  memset(dst_str, 0x00, 257);
11388  memset(iv_str, 0x00, 128);
11389  memset(add_str, 0x00, 128);
11390  memset(tag_str, 0x00, 128);
11391  memset(output, 0x00, 128);
11392 
11393  key_len = unhexify( key_str, "23c201968def551817f20e49b09dbb5aae0033305bef68a0" );
11394  pt_len = unhexify( src_str, "77bc8af42d1b64ee39012df5fc33c554af32bfef6d9182804dcfe370dfc4b9d059bdbc55f6ba4eacb8e3a491d96a65360d790864ba60acf1a605f6b28a6591513ea3cfd768ff47aee242a8e9bdfac399b452231bfd59d81c9b91f8dc589ad751d8f9fdad01dd00631f0cb51cb0248332f24194b577e5571ceb5c037a6d0bcfe8" );
11395  iv_len = unhexify( iv_str, "bd2952d215aed5e915d863e7f7696b3e" );
11396  add_len = unhexify( add_str, "23f35fac583897519b94998084ad6d77666e13595109e874625bc6ccc6d0c7816a62d64b02e670fa664e3bb52c276b1bafbeb44e5f9cc3ae028daf1d787344482f31fce5d2800020732b381a8b11c6837f428204b7ed2f4c4810067f2d4da99987b66e6525fc6b9217a8f6933f1681b7cfa857e102f616a7c84adc2f676e3a8f" );
11397  unhexify( tag_str, "bb9ba3a9ac7d63e67bd78d71dc3133b3" );
11398 
11399  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11400  if( 0 == 0 )
11401  {
11402  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11403 
11404  if( strcmp( "FAIL", "17d93c921009c6b0b3ecf243d08b701422983f2dcaec9c8d7604a2d5565ed96ce5cddcb183cd5882f8d61d3202c9015d207fed16a4c1195ba712428c727601135315fc504e80c253c3a2e4a5593fc6c4a206edce1fd7104e8a888385bbb396d3cdf1eb2b2aa4d0c9e45451e99550d9cfa05aafe6e7b5319c73c33fd6f98db3c5" ) == 0 )
11405  {
11406  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11407  }
11408  else
11409  {
11410  hexify( dst_str, output, pt_len );
11411 
11412  fct_chk( strcmp( (char *) dst_str, "17d93c921009c6b0b3ecf243d08b701422983f2dcaec9c8d7604a2d5565ed96ce5cddcb183cd5882f8d61d3202c9015d207fed16a4c1195ba712428c727601135315fc504e80c253c3a2e4a5593fc6c4a206edce1fd7104e8a888385bbb396d3cdf1eb2b2aa4d0c9e45451e99550d9cfa05aafe6e7b5319c73c33fd6f98db3c5" ) == 0 );
11413  }
11414  }
11415  }
11416  FCT_TEST_END();
11417 
11418 
11419  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024128_2)
11420  {
11421  unsigned char key_str[128];
11422  unsigned char src_str[128];
11423  unsigned char dst_str[257];
11424  unsigned char iv_str[128];
11425  unsigned char add_str[128];
11426  unsigned char tag_str[128];
11427  unsigned char output[128];
11428  gcm_context ctx;
11429  unsigned int key_len;
11430  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
11431  int ret;
11432 
11433  memset(key_str, 0x00, 128);
11434  memset(src_str, 0x00, 128);
11435  memset(dst_str, 0x00, 257);
11436  memset(iv_str, 0x00, 128);
11437  memset(add_str, 0x00, 128);
11438  memset(tag_str, 0x00, 128);
11439  memset(output, 0x00, 128);
11440 
11441  key_len = unhexify( key_str, "6baec0669add30acb8f678ce477a2b171f89d1f41935c491" );
11442  pt_len = unhexify( src_str, "5712b84c4c97d75f84edd50561bc1d3f1ba451cc3b358b2403b5e528290954348cf7a235b4dc11a72ddbc503191204e98a9744d85419508c8ca76438c13305f716f1e239a6d9f6423c27217a0057aa75f6d7e2fb356e7194f271459ab5482589ea311b33e3d3845952ff4067dd2b9bcc2e8f83630b0a219e904040abd643d839" );
11443  iv_len = unhexify( iv_str, "b1472f92f552ca0d62496b8fa622c569" );
11444  add_len = unhexify( add_str, "5ae64edf11b4dbc7294d3d01bc9faf310dc08a92b28e664e0a7525f938d32ef033033f1de8931f39a58df0eabc8784423f0a6355efcff008cae62c1d8e5b7baefd360a5a2aa1b7068522faf8e437e6419be305ada05715bf21d73bd227531fea4bc31a6ce1662aec49f1961ee28e33ae00eb20013fd84b51cfe0d5adbdaff592" );
11445  unhexify( tag_str, "29a2d607b2d2d9c96d093000b401a94f" );
11446 
11447  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11448  if( 0 == 0 )
11449  {
11450  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11451 
11452  if( strcmp( "FAIL", "beb687f062ae7f5159d07609dd58d7b81c478d180bc0b4c07ae799626ff1da2be2e0d78b2a2a1f563257f161491a5ac500cd719da6379e30d0f6d0a7a33203381e058f487fc60989923afbee76e703c03abc73bb01bd262ff6f0ac931f771e9b4f2980e7d8c0a9e939fa6e1094796894f2c78f453e4abe64cb285016435ef0e8" ) == 0 )
11453  {
11454  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11455  }
11456  else
11457  {
11458  hexify( dst_str, output, pt_len );
11459 
11460  fct_chk( strcmp( (char *) dst_str, "beb687f062ae7f5159d07609dd58d7b81c478d180bc0b4c07ae799626ff1da2be2e0d78b2a2a1f563257f161491a5ac500cd719da6379e30d0f6d0a7a33203381e058f487fc60989923afbee76e703c03abc73bb01bd262ff6f0ac931f771e9b4f2980e7d8c0a9e939fa6e1094796894f2c78f453e4abe64cb285016435ef0e8" ) == 0 );
11461  }
11462  }
11463  }
11464  FCT_TEST_END();
11465 
11466 
11467  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024120_0)
11468  {
11469  unsigned char key_str[128];
11470  unsigned char src_str[128];
11471  unsigned char dst_str[257];
11472  unsigned char iv_str[128];
11473  unsigned char add_str[128];
11474  unsigned char tag_str[128];
11475  unsigned char output[128];
11476  gcm_context ctx;
11477  unsigned int key_len;
11478  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
11479  int ret;
11480 
11481  memset(key_str, 0x00, 128);
11482  memset(src_str, 0x00, 128);
11483  memset(dst_str, 0x00, 257);
11484  memset(iv_str, 0x00, 128);
11485  memset(add_str, 0x00, 128);
11486  memset(tag_str, 0x00, 128);
11487  memset(output, 0x00, 128);
11488 
11489  key_len = unhexify( key_str, "7b882a2df81fdb9275fb05d120f32417e8ffedd07457e938" );
11490  pt_len = unhexify( src_str, "0aae7213da279b34d6dcf2a691b2d0333112ea22de0c3c68d47cf9f9f4ed8ad4e03d4a60ec18c3a04ac9c2abb73e1023051029b5e8705bb69c4c50afc84deb0379db5077be1f663652f8bd8958271af2c1ac4a87e08cb526bab8a030652f2a29af8055d0f31e35475caee27f84c156ef8642e5bfef89192f5bde3c54279ffe06" );
11491  iv_len = unhexify( iv_str, "5c064d3418b89388fb21c61d8c74d2c5" );
11492  add_len = unhexify( add_str, "5bfa7113d34e00f34713cf07c386d055e889bb42d7f6c8631ffce5668e98cb19bed8820b90ecb2b35df7134f975700347e5514287cfef7ffa2b0ff48b1de0769b03dca6610995d67cb80052cb2e5914eb4ed43ef5861f4b9364314fde6ad2b82fbba7fd849dfa6e46ecc12edc8cabfff28d9bd23c2bcc8ab3661c9ba4d5fee06" );
11493  unhexify( tag_str, "0943abb85adee47741540900cc833f" );
11494 
11495  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11496  if( 0 == 0 )
11497  {
11498  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11499 
11500  if( strcmp( "FAIL", "FAIL" ) == 0 )
11501  {
11502  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11503  }
11504  else
11505  {
11506  hexify( dst_str, output, pt_len );
11507 
11508  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11509  }
11510  }
11511  }
11512  FCT_TEST_END();
11513 
11514 
11515  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024120_1)
11516  {
11517  unsigned char key_str[128];
11518  unsigned char src_str[128];
11519  unsigned char dst_str[257];
11520  unsigned char iv_str[128];
11521  unsigned char add_str[128];
11522  unsigned char tag_str[128];
11523  unsigned char output[128];
11524  gcm_context ctx;
11525  unsigned int key_len;
11526  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
11527  int ret;
11528 
11529  memset(key_str, 0x00, 128);
11530  memset(src_str, 0x00, 128);
11531  memset(dst_str, 0x00, 257);
11532  memset(iv_str, 0x00, 128);
11533  memset(add_str, 0x00, 128);
11534  memset(tag_str, 0x00, 128);
11535  memset(output, 0x00, 128);
11536 
11537  key_len = unhexify( key_str, "51d94d21482c00bb5bc7e7e03aa017ba58f5a23494b72c2a" );
11538  pt_len = unhexify( src_str, "3a9c69c1ed2340bfde1495658dbf4f54731a19b3922a1d535df8d0b2582f5e803b5891e8ad1aa256c923956dcda2430d0c0696bce63295fb61183e040566e459338f908d23ae51f64020c1ef3d192428f23312b285fc4111d50d1add58f4a49008a22c90d3365230e9158cd56f9d84f079bdd673555d4dc76c74b02fa9920e7d" );
11539  iv_len = unhexify( iv_str, "fb21cd763e6f25540f8ad455deaccdf0" );
11540  add_len = unhexify( add_str, "019d1db5569eeff83306f65d653b01064854c1be8446cd2516336667c6557e7844fc349adea64a12dc19ac7e8e40b0520a48fac64571a93d669045607085ac9fa78fed99bbf644908d7763fe5f7f503947a9fe8661b7c6aef8da101acca0aed758ca1580eeb2f26ae3bf2de06ce8827a91a694179991a993cdf814efbcc61ca5" );
11541  unhexify( tag_str, "a93bd682b57e1d1bf4af97e93b8927" );
11542 
11543  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11544  if( 0 == 0 )
11545  {
11546  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11547 
11548  if( strcmp( "FAIL", "7093f44703f2cbb3d12d9872b07a8cd44deb62dae48bc573b11a1ee1c9f3105223423fac3181c312a8a61757a432d92719f486c21e311b840aa63cf530710c873df27fecda0956075923f1ecc39bffb862706f48bde2de15612930fc8630d2036e9e4cfc1c69779171bd23d9e1d5de50a9e0a0de4bd82ed3efc45299980bb4cc" ) == 0 )
11549  {
11550  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11551  }
11552  else
11553  {
11554  hexify( dst_str, output, pt_len );
11555 
11556  fct_chk( strcmp( (char *) dst_str, "7093f44703f2cbb3d12d9872b07a8cd44deb62dae48bc573b11a1ee1c9f3105223423fac3181c312a8a61757a432d92719f486c21e311b840aa63cf530710c873df27fecda0956075923f1ecc39bffb862706f48bde2de15612930fc8630d2036e9e4cfc1c69779171bd23d9e1d5de50a9e0a0de4bd82ed3efc45299980bb4cc" ) == 0 );
11557  }
11558  }
11559  }
11560  FCT_TEST_END();
11561 
11562 
11563  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024120_2)
11564  {
11565  unsigned char key_str[128];
11566  unsigned char src_str[128];
11567  unsigned char dst_str[257];
11568  unsigned char iv_str[128];
11569  unsigned char add_str[128];
11570  unsigned char tag_str[128];
11571  unsigned char output[128];
11572  gcm_context ctx;
11573  unsigned int key_len;
11574  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
11575  int ret;
11576 
11577  memset(key_str, 0x00, 128);
11578  memset(src_str, 0x00, 128);
11579  memset(dst_str, 0x00, 257);
11580  memset(iv_str, 0x00, 128);
11581  memset(add_str, 0x00, 128);
11582  memset(tag_str, 0x00, 128);
11583  memset(output, 0x00, 128);
11584 
11585  key_len = unhexify( key_str, "e6756470937f5d9af76f2abe6df2d0bc15ff8e39b5154071" );
11586  pt_len = unhexify( src_str, "afae92bd56c426c095d76633701aa9bea5ce05490482c6c64ac24468c3e1af6e6030a6bb6649745b011c6729bde985b9242e22105322fbb8853dcabbd00165d0b07d7b499e0238b6513bf6351eb40635a798f7e6e2d31125dda45ffe8964596fdbff55df22d4e9025bd4f39e7c9b90e74b3ee58d6901f113900ee47a4df5afd7" );
11587  iv_len = unhexify( iv_str, "4500193711a5d817a9f48deafda39772" );
11588  add_len = unhexify( add_str, "92fa22dba0eee6b1de1ddd24713b1be44c7105df90e6e7a54dcbf19025e560eb4986ee080cf613898a1a69d5ab460a3b8aa2723a95ac4a4af48224b011b55fb7582ae18f6746591eab2bd33d82a8dbbae3f7877e28afef9857a623530b31d8198b2df43f903d6e48ddae0848741f9eaae7b5504c67ad13791818f3c55c9b3d1e" );
11589  unhexify( tag_str, "7d9f97c97c3424c79966f5b45af090" );
11590 
11591  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11592  if( 0 == 0 )
11593  {
11594  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11595 
11596  if( strcmp( "FAIL", "62258d60f0138c0405df4b2ec1e308b374603a9eace45932fdc2999e9e2261de8b1099473d1fc741c46c334023aa5d9359f7ef966240aaf7e310d874b5956fd180fb1124cbeb91cf86020c78a1a0335f5f029bd34677dd2d5076482f3b3e85808f54998f4bac8b8fa968febceec3458fb882fc0530271f144fb3e2ab8c1a6289" ) == 0 )
11597  {
11598  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11599  }
11600  else
11601  {
11602  hexify( dst_str, output, pt_len );
11603 
11604  fct_chk( strcmp( (char *) dst_str, "62258d60f0138c0405df4b2ec1e308b374603a9eace45932fdc2999e9e2261de8b1099473d1fc741c46c334023aa5d9359f7ef966240aaf7e310d874b5956fd180fb1124cbeb91cf86020c78a1a0335f5f029bd34677dd2d5076482f3b3e85808f54998f4bac8b8fa968febceec3458fb882fc0530271f144fb3e2ab8c1a6289" ) == 0 );
11605  }
11606  }
11607  }
11608  FCT_TEST_END();
11609 
11610 
11611  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024112_0)
11612  {
11613  unsigned char key_str[128];
11614  unsigned char src_str[128];
11615  unsigned char dst_str[257];
11616  unsigned char iv_str[128];
11617  unsigned char add_str[128];
11618  unsigned char tag_str[128];
11619  unsigned char output[128];
11620  gcm_context ctx;
11621  unsigned int key_len;
11622  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
11623  int ret;
11624 
11625  memset(key_str, 0x00, 128);
11626  memset(src_str, 0x00, 128);
11627  memset(dst_str, 0x00, 257);
11628  memset(iv_str, 0x00, 128);
11629  memset(add_str, 0x00, 128);
11630  memset(tag_str, 0x00, 128);
11631  memset(output, 0x00, 128);
11632 
11633  key_len = unhexify( key_str, "30db73d46b518669c45b81bc67b93bed3d0864f7e9e8e789" );
11634  pt_len = unhexify( src_str, "750bc1d2f91d786bb1e621192a376f552538ba8c07d50d9e10b9345f31b3e5f9d8ad7c719c03d8548a3b184b741cd06c49d7fb6fe80258d60c01c2987c337c823211cee7c1cf82077266889bc7767475e0eeabb2ef6b5a1de2089aaef77565d40a1c2c470a880c911e77a186eacca173b25970574f05c0bdcd5428b39b52af7f" );
11635  iv_len = unhexify( iv_str, "5069e2d2f82b36de8c2eb171f301135d" );
11636  add_len = unhexify( add_str, "ef781dce556b84188adee2b6e1d64dac2751dd8592abc6c72af7b998dfae40cbe692a4cae0b4aa2c95910e270600550fca1e83640c64efb1eb0e0a90a6fc475ae1db863a64ce9cc272f00abac8a63d48dd9f1c0a5f4586224befed05be4afae5bd92249833d565cc6b65fd8955cb8a7d7bd9f4b6a229e3881212871a52c15d1c" );
11637  unhexify( tag_str, "a5100c5e9a16aedf0e1bd8604335" );
11638 
11639  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11640  if( 0 == 0 )
11641  {
11642  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11643 
11644  if( strcmp( "FAIL", "FAIL" ) == 0 )
11645  {
11646  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11647  }
11648  else
11649  {
11650  hexify( dst_str, output, pt_len );
11651 
11652  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11653  }
11654  }
11655  }
11656  FCT_TEST_END();
11657 
11658 
11659  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024112_1)
11660  {
11661  unsigned char key_str[128];
11662  unsigned char src_str[128];
11663  unsigned char dst_str[257];
11664  unsigned char iv_str[128];
11665  unsigned char add_str[128];
11666  unsigned char tag_str[128];
11667  unsigned char output[128];
11668  gcm_context ctx;
11669  unsigned int key_len;
11670  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
11671  int ret;
11672 
11673  memset(key_str, 0x00, 128);
11674  memset(src_str, 0x00, 128);
11675  memset(dst_str, 0x00, 257);
11676  memset(iv_str, 0x00, 128);
11677  memset(add_str, 0x00, 128);
11678  memset(tag_str, 0x00, 128);
11679  memset(output, 0x00, 128);
11680 
11681  key_len = unhexify( key_str, "209f0478f1a62cb54c551181cbd4d24b796e95f3a06b6cb9" );
11682  pt_len = unhexify( src_str, "66db7cc97b4a8266c0a2228e8028e38d8986e79fcbcc3caff3050fdd2de87b7ff7a6895b988b0bdb7fcc4d6e2d538dcfaad43ce2f98b6d32500f5a6e6183d84cb19157a699cdde1266d6d75a251ee1a2eb97bfe6405d50be2b17a58ba6eafaee0a023a28d568fd1c914f06041a49c79b9df9efe63d56883cbbbeaba809273d2e" );
11683  iv_len = unhexify( iv_str, "7be1768f6ffb31599eb6def7d1daa41c" );
11684  add_len = unhexify( add_str, "9cb49357536ebe087e1475a5387907a9e51ad1550697f13c6cc04384ec8a67dea13376bdd5e26b815c84a78f921b506b9e2086de50f849185f05ba7c3041e49e42c0673df856da109a78b8e0ce918c25836f7e781e6b16168e4e5976d27ebc83f20b7bf4beadecb9b4f17a7a0d3a3db27fc65288a754b5031a2f5a1394801e6e" );
11685  unhexify( tag_str, "4d2ac05bfd4b59b15a6f70ea7cd0" );
11686 
11687  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11688  if( 0 == 0 )
11689  {
11690  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11691 
11692  if( strcmp( "FAIL", "FAIL" ) == 0 )
11693  {
11694  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11695  }
11696  else
11697  {
11698  hexify( dst_str, output, pt_len );
11699 
11700  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11701  }
11702  }
11703  }
11704  FCT_TEST_END();
11705 
11706 
11707  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024112_2)
11708  {
11709  unsigned char key_str[128];
11710  unsigned char src_str[128];
11711  unsigned char dst_str[257];
11712  unsigned char iv_str[128];
11713  unsigned char add_str[128];
11714  unsigned char tag_str[128];
11715  unsigned char output[128];
11716  gcm_context ctx;
11717  unsigned int key_len;
11718  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
11719  int ret;
11720 
11721  memset(key_str, 0x00, 128);
11722  memset(src_str, 0x00, 128);
11723  memset(dst_str, 0x00, 257);
11724  memset(iv_str, 0x00, 128);
11725  memset(add_str, 0x00, 128);
11726  memset(tag_str, 0x00, 128);
11727  memset(output, 0x00, 128);
11728 
11729  key_len = unhexify( key_str, "1bfa30b315e7b908263330140fa2d66ed57104784a43cc70" );
11730  pt_len = unhexify( src_str, "8eeee9865e23fa51dbbf197fa41776b7edbdb9381a22c935299cd959a46190788ae82f4e645b0362df89bfc00241964784bc7ef70f6f97e81687d52e552a33af20ae34a3005e0a7b85d094368d707c3c4cd3ef31c0daf3ccaa1676609ed199327f4139d0c120977e6babceed28896d2cb3129630f3ee135572dc39433057e26a" );
11731  iv_len = unhexify( iv_str, "b7081a3010b524218390ba6dd460a1ec" );
11732  add_len = unhexify( add_str, "8c1f42b5931d69ae351fcde7d2b4136d4898a4fa8ba62d55cef721dadf19beaabf9d1900bdf2e58ee568b808684eecbf7aa3c890f65c54b967b94484be082193b2d8393007389abaa9debbb49d727a2ac16b4dab2c8f276840e9c65a47974d9b04f2e63adf38b6aad763f0d7cdb2c3d58691adde6e51e0a85093a4c4944f5bf2" );
11733  unhexify( tag_str, "4da85b8ec861dd8be54787bb83f1" );
11734 
11735  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11736  if( 0 == 0 )
11737  {
11738  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11739 
11740  if( strcmp( "FAIL", "FAIL" ) == 0 )
11741  {
11742  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11743  }
11744  else
11745  {
11746  hexify( dst_str, output, pt_len );
11747 
11748  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11749  }
11750  }
11751  }
11752  FCT_TEST_END();
11753 
11754 
11755  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024104_0)
11756  {
11757  unsigned char key_str[128];
11758  unsigned char src_str[128];
11759  unsigned char dst_str[257];
11760  unsigned char iv_str[128];
11761  unsigned char add_str[128];
11762  unsigned char tag_str[128];
11763  unsigned char output[128];
11764  gcm_context ctx;
11765  unsigned int key_len;
11766  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
11767  int ret;
11768 
11769  memset(key_str, 0x00, 128);
11770  memset(src_str, 0x00, 128);
11771  memset(dst_str, 0x00, 257);
11772  memset(iv_str, 0x00, 128);
11773  memset(add_str, 0x00, 128);
11774  memset(tag_str, 0x00, 128);
11775  memset(output, 0x00, 128);
11776 
11777  key_len = unhexify( key_str, "fc47156a693e59a1dea0618c41441fe669fc65dcfb7d0726" );
11778  pt_len = unhexify( src_str, "3e4f0a586bad532a08c8863ebba01fd25014baa907e6032ee43d4a7dfc7c3171916dcdf9faee0531f27527872ae4e127b6b9aaee93f5e74d0ab23f3874aa0e291564bc97f17085dd7d5eb9a85d9f44574e5952929eda08863b64c85dd395c91b01fe5bef66e3fa8f9ee5bf62c25d80dc84fbe002ecfd218430b26f3549f734a1" );
11779  iv_len = unhexify( iv_str, "ea1935ed014883cc427983d7962d9992" );
11780  add_len = unhexify( add_str, "0d85b8513becfe8c91d0f6ffb65ec31f2cf406c51c0da88893c43d1327fd8ad1f4bab2d7b5e27438d643397034a72f8666bf641b6781bc90f764db387eae6720b5723d510194570ccd773e1b3bebfc333cc099d078583e8dac60d174d332925a24a45110c8d2abe8924ea677ac74db66ea789e2838efc96c78bceaa6236c0a67" );
11781  unhexify( tag_str, "8781b045a509c4239b9f44624e" );
11782 
11783  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11784  if( 0 == 0 )
11785  {
11786  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11787 
11788  if( strcmp( "FAIL", "FAIL" ) == 0 )
11789  {
11790  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11791  }
11792  else
11793  {
11794  hexify( dst_str, output, pt_len );
11795 
11796  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11797  }
11798  }
11799  }
11800  FCT_TEST_END();
11801 
11802 
11803  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024104_1)
11804  {
11805  unsigned char key_str[128];
11806  unsigned char src_str[128];
11807  unsigned char dst_str[257];
11808  unsigned char iv_str[128];
11809  unsigned char add_str[128];
11810  unsigned char tag_str[128];
11811  unsigned char output[128];
11812  gcm_context ctx;
11813  unsigned int key_len;
11814  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
11815  int ret;
11816 
11817  memset(key_str, 0x00, 128);
11818  memset(src_str, 0x00, 128);
11819  memset(dst_str, 0x00, 257);
11820  memset(iv_str, 0x00, 128);
11821  memset(add_str, 0x00, 128);
11822  memset(tag_str, 0x00, 128);
11823  memset(output, 0x00, 128);
11824 
11825  key_len = unhexify( key_str, "b5fcd780a03ba80341081ef96b440c0e4348afde4d60c1d5" );
11826  pt_len = unhexify( src_str, "6316f3beb32f6f3bf8f2ff6a2c160b432bafd3036d3eefa1e4ec204f24892e37dc4d75c7ce9a24b5c49fb4df901f35ef9d5955f7dc289c56cb74753f4d6b2982267d5269d12237e21202a65061849c65e90e6702dda03a35ace3a3a098d16b4bfbb85b7232404baee37776a9b51af6b3059a5f170f4ebe4ecf11061ca3c1f1f3" );
11827  iv_len = unhexify( iv_str, "ad20cce056e74ec5d0a76d6280998f15" );
11828  add_len = unhexify( add_str, "28f8fcf23b9c1ba40c19ffc1092632e35f234c1e8b82bcd5309d37bf849a2ce401413d1f242cf255ed597f9a93a1d6e50676997f95aa612e580d88234a86ddc404292746f0b2f5cf15abebcea6659f998ec6a1cb5a9914fee5aa1aa5d04b3c20914e45095e4141ce9c173653dd91c3ebe4ed4a9a28f3915d7b2edba34c2a58d8" );
11829  unhexify( tag_str, "2ad4520ddc3b907414d934cc1d" );
11830 
11831  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11832  if( 0 == 0 )
11833  {
11834  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11835 
11836  if( strcmp( "FAIL", "FAIL" ) == 0 )
11837  {
11838  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11839  }
11840  else
11841  {
11842  hexify( dst_str, output, pt_len );
11843 
11844  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11845  }
11846  }
11847  }
11848  FCT_TEST_END();
11849 
11850 
11851  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024104_2)
11852  {
11853  unsigned char key_str[128];
11854  unsigned char src_str[128];
11855  unsigned char dst_str[257];
11856  unsigned char iv_str[128];
11857  unsigned char add_str[128];
11858  unsigned char tag_str[128];
11859  unsigned char output[128];
11860  gcm_context ctx;
11861  unsigned int key_len;
11862  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
11863  int ret;
11864 
11865  memset(key_str, 0x00, 128);
11866  memset(src_str, 0x00, 128);
11867  memset(dst_str, 0x00, 257);
11868  memset(iv_str, 0x00, 128);
11869  memset(add_str, 0x00, 128);
11870  memset(tag_str, 0x00, 128);
11871  memset(output, 0x00, 128);
11872 
11873  key_len = unhexify( key_str, "4382507dddccf1385fc831da8924147563416d0656e168ec" );
11874  pt_len = unhexify( src_str, "e5c5430b960aa35dc8540215c2772d66811270859e33dd4477904759e7e5eb2986a52a4ccc9f592e614147b5ea2ead6636a15c6426336b2995d9a31ab36d76578c3540bc6693842a4bc0491c7963ee9cda2317951cf93244bd30bcdfec69a4767004636fe7d1be7300c35e80627bab9236a075a803e9e1080b9159060c643a78" );
11875  iv_len = unhexify( iv_str, "a37687c9cd4bdc1ead4e6b8f78bee7f5" );
11876  add_len = unhexify( add_str, "fa9ae30509cbb6fe104c21480ae7b8ec9f12f1afb17320d77b77cdf32ce8c5a3f7f927e501118c7ccd6975b79225059cef530a4fcb0a9719f5e2d3bebe7bb6ec0855e495a31e5075eb50aa6c1227e48b03e3fdf780084ac4912eb3a5674cca9dd6ac037366b230ae631a8580d2d117942dee5d5ddbbb2233afeca53289cc4f68" );
11877  unhexify( tag_str, "4221818d4be45306e205813789" );
11878 
11879  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11880  if( 0 == 0 )
11881  {
11882  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11883 
11884  if( strcmp( "FAIL", "b5b36719bc4d13a5fbf37188ea814cdf3c97a430784330540325c899570e15482300bc82c5b8163074e0544c5132e3ce93bba68bd7a8d2db81d1431b424b697c1158c4d70625666d5ff99145ca34856815c905b5a0fd95806df56b9cd5b384bda3e394b409048eb1037144cc071539c02397e931da28a43cc354d584643afd4f" ) == 0 )
11885  {
11886  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11887  }
11888  else
11889  {
11890  hexify( dst_str, output, pt_len );
11891 
11892  fct_chk( strcmp( (char *) dst_str, "b5b36719bc4d13a5fbf37188ea814cdf3c97a430784330540325c899570e15482300bc82c5b8163074e0544c5132e3ce93bba68bd7a8d2db81d1431b424b697c1158c4d70625666d5ff99145ca34856815c905b5a0fd95806df56b9cd5b384bda3e394b409048eb1037144cc071539c02397e931da28a43cc354d584643afd4f" ) == 0 );
11893  }
11894  }
11895  }
11896  FCT_TEST_END();
11897 
11898 
11899  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102496_0)
11900  {
11901  unsigned char key_str[128];
11902  unsigned char src_str[128];
11903  unsigned char dst_str[257];
11904  unsigned char iv_str[128];
11905  unsigned char add_str[128];
11906  unsigned char tag_str[128];
11907  unsigned char output[128];
11908  gcm_context ctx;
11909  unsigned int key_len;
11910  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
11911  int ret;
11912 
11913  memset(key_str, 0x00, 128);
11914  memset(src_str, 0x00, 128);
11915  memset(dst_str, 0x00, 257);
11916  memset(iv_str, 0x00, 128);
11917  memset(add_str, 0x00, 128);
11918  memset(tag_str, 0x00, 128);
11919  memset(output, 0x00, 128);
11920 
11921  key_len = unhexify( key_str, "7a66db3450dac9a1e63d2639f34c5c6a3fbfb3c8e8230199" );
11922  pt_len = unhexify( src_str, "6463a7eb2496379bc8a5635541525926a6f9fa718e338221952118ae4cf03a85f2074b4ebaf108b9c725809be1e6309c3a444b66f12286f6ea9d80c3413706b234b26372e8f00783819314a994c9e3ecf6abdd255cbfe01b3865e1390a35dcd2853a3d99ed992e82ec67ba245f088cb090adade74bdbc8a1bad0f06cbea766a6" );
11923  iv_len = unhexify( iv_str, "21f8341529b210ade7f2c6055e13007a" );
11924  add_len = unhexify( add_str, "1699bc8c198ab03e22d9bc4f3682aad335c6e35f3f616bb69769a9d5a202511797e770ae0d8d8528ef7b2bb25b4294d47427b43f0580fa71d93fdef667f4f4196f84e41c0b1978796d0de74a94420fb8571bff39137fa231c572b31be9ae72338288bef5f8c992121dc918538551f346e279a9047df14ec9fc0fd399cd3bd8d8" );
11925  unhexify( tag_str, "4af02b81b26104d1d31e295a" );
11926 
11927  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11928  if( 0 == 0 )
11929  {
11930  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11931 
11932  if( strcmp( "FAIL", "53fe6a34d280f2c96d1ae2b2e8baf6abd67cedf7d214312f75dd4a1bec28a641dda3e71aa398726b2b0b1f515e1f4259ee97acaf17f122db9ec7814c2de6a88d36c3ac106396ad03d337c2cd2d2b9b4b7170e23a5848ca7ea129838f967dfdfe83b45ff2a9be699bfb2346115465d59f074f09e24d8fcbd9ece0018c92776c43" ) == 0 )
11933  {
11934  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11935  }
11936  else
11937  {
11938  hexify( dst_str, output, pt_len );
11939 
11940  fct_chk( strcmp( (char *) dst_str, "53fe6a34d280f2c96d1ae2b2e8baf6abd67cedf7d214312f75dd4a1bec28a641dda3e71aa398726b2b0b1f515e1f4259ee97acaf17f122db9ec7814c2de6a88d36c3ac106396ad03d337c2cd2d2b9b4b7170e23a5848ca7ea129838f967dfdfe83b45ff2a9be699bfb2346115465d59f074f09e24d8fcbd9ece0018c92776c43" ) == 0 );
11941  }
11942  }
11943  }
11944  FCT_TEST_END();
11945 
11946 
11947  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102496_1)
11948  {
11949  unsigned char key_str[128];
11950  unsigned char src_str[128];
11951  unsigned char dst_str[257];
11952  unsigned char iv_str[128];
11953  unsigned char add_str[128];
11954  unsigned char tag_str[128];
11955  unsigned char output[128];
11956  gcm_context ctx;
11957  unsigned int key_len;
11958  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
11959  int ret;
11960 
11961  memset(key_str, 0x00, 128);
11962  memset(src_str, 0x00, 128);
11963  memset(dst_str, 0x00, 257);
11964  memset(iv_str, 0x00, 128);
11965  memset(add_str, 0x00, 128);
11966  memset(tag_str, 0x00, 128);
11967  memset(output, 0x00, 128);
11968 
11969  key_len = unhexify( key_str, "1f5c818f24d201f9fb23fcca211b0545eee5c5c9b440810d" );
11970  pt_len = unhexify( src_str, "9a7566817a06f792e96a6a2ba8e0a01f8837e2de06796e68b0782cc54ed0b04fc5e24a1ad37d5ffb035548b882d88150e89915b89f57cde2bf3c43ab9dae356927daef6bd61cc9edd5e1b7a4abea2f71313677f1b2fdf3d8d4a7e9814ea820fbc3e5c83947db961839a985a57ced7f5e4a1efffcfd17a2c806d4cdc1e79162da" );
11971  iv_len = unhexify( iv_str, "3a163067bdd90fce0406d1c198a88771" );
11972  add_len = unhexify( add_str, "a5e94e233d04fe0c4b6c4684b386902fe05096702237dfbe76f73befa69b6f30394cf9fe3358997942df65842748fb4f075a3dc06e147bd8d67fc4371113a4d75c70219257c650a6f38a136659e20a1cf3a119397835c304e0fb2a33aa3c3019175c86463043d5edc6992874f61e81cd0d26af8b62cf8c8626901d4f16d84236" );
11973  unhexify( tag_str, "b124eea927e2a62a875494a1" );
11974 
11975  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
11976  if( 0 == 0 )
11977  {
11978  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
11979 
11980  if( strcmp( "FAIL", "FAIL" ) == 0 )
11981  {
11982  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
11983  }
11984  else
11985  {
11986  hexify( dst_str, output, pt_len );
11987 
11988  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
11989  }
11990  }
11991  }
11992  FCT_TEST_END();
11993 
11994 
11995  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102496_2)
11996  {
11997  unsigned char key_str[128];
11998  unsigned char src_str[128];
11999  unsigned char dst_str[257];
12000  unsigned char iv_str[128];
12001  unsigned char add_str[128];
12002  unsigned char tag_str[128];
12003  unsigned char output[128];
12004  gcm_context ctx;
12005  unsigned int key_len;
12006  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
12007  int ret;
12008 
12009  memset(key_str, 0x00, 128);
12010  memset(src_str, 0x00, 128);
12011  memset(dst_str, 0x00, 257);
12012  memset(iv_str, 0x00, 128);
12013  memset(add_str, 0x00, 128);
12014  memset(tag_str, 0x00, 128);
12015  memset(output, 0x00, 128);
12016 
12017  key_len = unhexify( key_str, "9a301f7edf83da63bcf37216a3a33d7613331c3210281dd7" );
12018  pt_len = unhexify( src_str, "e09cc8543db7804870004706a26e94b457c125bd648b581a196f962f2ae8fa55d9bc66530ba5020e22d282080b4720dc9a2096a11c0fcc3d9a67cd1cf95cd7cd2417ba308c761e64be24347a14c9423447094a5c72a0043c288b35e753ba0aa748f208381249fb1c8d195a472192404b6c8172663ee4b4d4ecfa426e1fb003f2" );
12019  iv_len = unhexify( iv_str, "d73a546b0fa307633ac89506fa86138b" );
12020  add_len = unhexify( add_str, "f57fe548cf4a551a216ffb24a1dcf1b79c95f9abf06443fd58af042d287c2165db373c82a94172db517840f22e45e966e3ead91ce1ddad132bcb844e406e84b76a0b5b0ee23064b66a229f32a2d3b9c71103f020c4ba57fc0f0608b7114914cf2ada0c5a9bc4afbfa9ce5da320f34beb2211d569a142f53bfd262f6d149c4350" );
12021  unhexify( tag_str, "f536a3b8c333b1aa520d6440" );
12022 
12023  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12024  if( 0 == 0 )
12025  {
12026  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12027 
12028  if( strcmp( "FAIL", "124a327a8c22b7652886dac2c84b8997ca8a6f61c9ba9c094b5aea41eaa050a6df6cbf280259e5466071bcfa53b4ebc76c3cc4afc8c0385189a5382933aa57c89aab78dca84331e0fe8f0aab3a7857d3e13f08dcd90ec5f0684f82088ef8eb7fd67e75de43b67afc3a0beb458f5ebd61b2c779e6c539d795c667bb7dcc2b762e" ) == 0 )
12029  {
12030  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12031  }
12032  else
12033  {
12034  hexify( dst_str, output, pt_len );
12035 
12036  fct_chk( strcmp( (char *) dst_str, "124a327a8c22b7652886dac2c84b8997ca8a6f61c9ba9c094b5aea41eaa050a6df6cbf280259e5466071bcfa53b4ebc76c3cc4afc8c0385189a5382933aa57c89aab78dca84331e0fe8f0aab3a7857d3e13f08dcd90ec5f0684f82088ef8eb7fd67e75de43b67afc3a0beb458f5ebd61b2c779e6c539d795c667bb7dcc2b762e" ) == 0 );
12037  }
12038  }
12039  }
12040  FCT_TEST_END();
12041 
12042 
12043  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102464_0)
12044  {
12045  unsigned char key_str[128];
12046  unsigned char src_str[128];
12047  unsigned char dst_str[257];
12048  unsigned char iv_str[128];
12049  unsigned char add_str[128];
12050  unsigned char tag_str[128];
12051  unsigned char output[128];
12052  gcm_context ctx;
12053  unsigned int key_len;
12054  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
12055  int ret;
12056 
12057  memset(key_str, 0x00, 128);
12058  memset(src_str, 0x00, 128);
12059  memset(dst_str, 0x00, 257);
12060  memset(iv_str, 0x00, 128);
12061  memset(add_str, 0x00, 128);
12062  memset(tag_str, 0x00, 128);
12063  memset(output, 0x00, 128);
12064 
12065  key_len = unhexify( key_str, "fd40e8226fd13cb95ba50b7cdf0f07f7ab7037cf8705ca50" );
12066  pt_len = unhexify( src_str, "75aa7df5c3c443d48ee998064b6fd112c20d2d90c98e00d025ef08d1ad3595385be99de47fa627549b827c48bc79eb1dcaf2f1be95a45f7e55755b952aee5ae0748e68bee1b014a628f3f7dc88e0ebac1d1d00e268355f5101838ce125c57003aebc02a1c9d6ae2cd6e2592f52c0be38cef21a680ae35c909cab99dce9837aef" );
12067  iv_len = unhexify( iv_str, "3406e70cbe16b047fedaa537eb892279" );
12068  add_len = unhexify( add_str, "390b18d22d5ecc0b5a524ae9afac6fd948ac72d1360775a88b385aa862cce8a27f3e4b420e539bec6e8958f8c1b5416c313fa0a16f921149a2bfeae29ad2348949b29a73970e5be925ec0c35218b82a020cf21bb68c6931f86b29e01b85500a73f3ee7eb78da60078f42550da83b2e301d151d69b273a050f89e57dfc4787cbf" );
12069  unhexify( tag_str, "69e06c72ead69501" );
12070 
12071  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12072  if( 0 == 0 )
12073  {
12074  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12075 
12076  if( strcmp( "FAIL", "6e8d661cd320b1b39f8494836fcf738b0ab82873d3903c9ee34d74f618aea36099926b54c1589225ec9a9d48ca53657f10d9289c31f199c37c48fb9cbe1cda1e790aaeedf73871f66a3761625cca3c4f642bc4f254868f6b903e80ceeeb015569ace23376567d3712ad16d1289dc504f15d9b2751b23e7722b9e6d8e0827859f" ) == 0 )
12077  {
12078  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12079  }
12080  else
12081  {
12082  hexify( dst_str, output, pt_len );
12083 
12084  fct_chk( strcmp( (char *) dst_str, "6e8d661cd320b1b39f8494836fcf738b0ab82873d3903c9ee34d74f618aea36099926b54c1589225ec9a9d48ca53657f10d9289c31f199c37c48fb9cbe1cda1e790aaeedf73871f66a3761625cca3c4f642bc4f254868f6b903e80ceeeb015569ace23376567d3712ad16d1289dc504f15d9b2751b23e7722b9e6d8e0827859f" ) == 0 );
12085  }
12086  }
12087  }
12088  FCT_TEST_END();
12089 
12090 
12091  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102464_1)
12092  {
12093  unsigned char key_str[128];
12094  unsigned char src_str[128];
12095  unsigned char dst_str[257];
12096  unsigned char iv_str[128];
12097  unsigned char add_str[128];
12098  unsigned char tag_str[128];
12099  unsigned char output[128];
12100  gcm_context ctx;
12101  unsigned int key_len;
12102  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
12103  int ret;
12104 
12105  memset(key_str, 0x00, 128);
12106  memset(src_str, 0x00, 128);
12107  memset(dst_str, 0x00, 257);
12108  memset(iv_str, 0x00, 128);
12109  memset(add_str, 0x00, 128);
12110  memset(tag_str, 0x00, 128);
12111  memset(output, 0x00, 128);
12112 
12113  key_len = unhexify( key_str, "a85ab87563b809b01725764d64ba4cc6a143e2e0362f0c52" );
12114  pt_len = unhexify( src_str, "ef43629721b50bd3656b7ae31b6e4b4ba1cf2c72ed0460ee7d9fb416631ddc597e5f9aebbcf4442b95cc46e28476a464dd87caf9c1c1d6c99d3e3e059dc23f8d2fe155ff5e59c50d640bc052c62adee3aa1295b38732e3458f379e98a8dbdfed04c22a5761792e87fa67ecbcbf3b90eb1bcd1d3f49e60132452f28afece83e90" );
12115  iv_len = unhexify( iv_str, "9f991ff16a3e3eb164a4f819c9f1821a" );
12116  add_len = unhexify( add_str, "df289511f78d8fa2505afc4c71ab1d7c31a8d15d1e5fcbb29d70f0e56f89c4d7b30f1b3b4745b5d2cc7af34fb4c95461372bf516ec192b400dc8fdb0ca9fe1f30f5320d0fadf20155cfcddcf09233c6f591c1c89917e38a003f56b94a1e2429d1f2b6297db790d7dce84d9fa13d2d86a0e4d100e154050b07178bee4cdf18126" );
12117  unhexify( tag_str, "dc4c97fe8cc53350" );
12118 
12119  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12120  if( 0 == 0 )
12121  {
12122  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12123 
12124  if( strcmp( "FAIL", "ff0e531c7344f0425d62d5fbedf4bc8d3d5cc80647e67b852c1a58ad1516d376d954cb8dda739f6a4df3cf1507e59696610bcb6b34340d6313028e00d7197845d392e73331aaf168b474a67364d8f9dab740509fabf92af75045f0afabc1b5829264d138820952bbc484d1100d058a4de32b4ece82746b2b4a85fb2993d4add8" ) == 0 )
12125  {
12126  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12127  }
12128  else
12129  {
12130  hexify( dst_str, output, pt_len );
12131 
12132  fct_chk( strcmp( (char *) dst_str, "ff0e531c7344f0425d62d5fbedf4bc8d3d5cc80647e67b852c1a58ad1516d376d954cb8dda739f6a4df3cf1507e59696610bcb6b34340d6313028e00d7197845d392e73331aaf168b474a67364d8f9dab740509fabf92af75045f0afabc1b5829264d138820952bbc484d1100d058a4de32b4ece82746b2b4a85fb2993d4add8" ) == 0 );
12133  }
12134  }
12135  }
12136  FCT_TEST_END();
12137 
12138 
12139  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102464_2)
12140  {
12141  unsigned char key_str[128];
12142  unsigned char src_str[128];
12143  unsigned char dst_str[257];
12144  unsigned char iv_str[128];
12145  unsigned char add_str[128];
12146  unsigned char tag_str[128];
12147  unsigned char output[128];
12148  gcm_context ctx;
12149  unsigned int key_len;
12150  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
12151  int ret;
12152 
12153  memset(key_str, 0x00, 128);
12154  memset(src_str, 0x00, 128);
12155  memset(dst_str, 0x00, 257);
12156  memset(iv_str, 0x00, 128);
12157  memset(add_str, 0x00, 128);
12158  memset(tag_str, 0x00, 128);
12159  memset(output, 0x00, 128);
12160 
12161  key_len = unhexify( key_str, "f4f1e03abb927ffd0b081b9dce83a56a6dd419a6313ac34f" );
12162  pt_len = unhexify( src_str, "0e70421499bc4bcb3851afa34cdf5be374722815abdd9bcee5f332dbe890bdc1c0210ab10667e5bb924bf3c1120e25a0c074da620076f143940989e222086d1b34a1200d09aea1f810ef6de7d8520c65eef9539fde5a6422606c588fce6264e5f91f934ede6397c4b307d2d7e07a518fce577a427fa92923cbba637ae495afad" );
12163  iv_len = unhexify( iv_str, "d1e29bb51a3c4e871d15bb0cd86257e2" );
12164  add_len = unhexify( add_str, "ae2911cdaaad1194c5d7868b6d8f30287105df132eb0cecca14b6e23ec7ac39cc01da1c567a0219cca7b902cc2e825e30f9524a473eb6e1d4d1beff5ab4f29103b2c7522a33dd33182fa955c4f09a75196b1072a6f0340fc55a802d29c7067f05219c21857ebff89ada11f648c1f28dfbfdaab56028f05509de17e2381457ebc" );
12165  unhexify( tag_str, "44f760787f7bc3c0" );
12166 
12167  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12168  if( 0 == 0 )
12169  {
12170  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12171 
12172  if( strcmp( "FAIL", "2199fa5051461b67581429ab19de2ccb50b8b02e12c0e1d81a8a14929f84e09d9715b7d198e77e632de4af1c08c5041276204a7ed76646385e288e96e1a4b0b0f2b1a9df7f0892beaea3cb58d9632720158f6daa4cbbfc0ebdc56ff6a5175768ff2abd24cb7669bc3fe40f8aba7869d2dd7dac86b6ebc4e4ce261edbec88db17" ) == 0 )
12173  {
12174  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12175  }
12176  else
12177  {
12178  hexify( dst_str, output, pt_len );
12179 
12180  fct_chk( strcmp( (char *) dst_str, "2199fa5051461b67581429ab19de2ccb50b8b02e12c0e1d81a8a14929f84e09d9715b7d198e77e632de4af1c08c5041276204a7ed76646385e288e96e1a4b0b0f2b1a9df7f0892beaea3cb58d9632720158f6daa4cbbfc0ebdc56ff6a5175768ff2abd24cb7669bc3fe40f8aba7869d2dd7dac86b6ebc4e4ce261edbec88db17" ) == 0 );
12181  }
12182  }
12183  }
12184  FCT_TEST_END();
12185 
12186 
12187  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102432_0)
12188  {
12189  unsigned char key_str[128];
12190  unsigned char src_str[128];
12191  unsigned char dst_str[257];
12192  unsigned char iv_str[128];
12193  unsigned char add_str[128];
12194  unsigned char tag_str[128];
12195  unsigned char output[128];
12196  gcm_context ctx;
12197  unsigned int key_len;
12198  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
12199  int ret;
12200 
12201  memset(key_str, 0x00, 128);
12202  memset(src_str, 0x00, 128);
12203  memset(dst_str, 0x00, 257);
12204  memset(iv_str, 0x00, 128);
12205  memset(add_str, 0x00, 128);
12206  memset(tag_str, 0x00, 128);
12207  memset(output, 0x00, 128);
12208 
12209  key_len = unhexify( key_str, "33efe20433c6a1ad261a1fed494961749e5bf9d35809b59d" );
12210  pt_len = unhexify( src_str, "cfbeb61be50def25f513346498f75984bfe797a8ad56be34f2461e2d673f6ce14e7479a59777267b75dadc6b9522599ebe5d7b079495a58ca187ec47796f6ee8c322278ad7451b038c938928adcff6105a8ea3780aedc45b6a3323d3ae6fbce5da4fb59ca5ec0a16a70494c3c4859672348532505e44f915e0b9b8a296ef5225" );
12211  iv_len = unhexify( iv_str, "dc94673b0c49c6d3b4611e278212c748" );
12212  add_len = unhexify( add_str, "919f7397a6d03836423b7cac53177fcfbe457d4aa4348646f646aae1bc5a15568cdb8c96fabef278ace248aca531110a4f4f9e8ab0c32525ad816ae3facf03175232dc84addcd6065f9cc1f513966b63fd27e91a09f1921b95d6bd8f08f1dbce073bcf827847f774514b478b9d7fb5426847dd4dee6f39b5768c1fb729b32d03" );
12213  unhexify( tag_str, "c5098340" );
12214 
12215  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12216  if( 0 == 0 )
12217  {
12218  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12219 
12220  if( strcmp( "FAIL", "c5e47d8c60b04df1974b68a14095d9bc8429a413d21960b15bae4fd7356bf7872e0da0a1a385ca2982d3aa3182e63ea4bb8ca01410cd4e71ddad34aa1f12c1387902b3d56634f89c619a2e6756648ab3bf90e9bc945afc9140eb935b633bae96bb067e9ee421697bcf80b14b1b88dbf13e010b472a7ca5411db36848b9c7a37f" ) == 0 )
12221  {
12222  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12223  }
12224  else
12225  {
12226  hexify( dst_str, output, pt_len );
12227 
12228  fct_chk( strcmp( (char *) dst_str, "c5e47d8c60b04df1974b68a14095d9bc8429a413d21960b15bae4fd7356bf7872e0da0a1a385ca2982d3aa3182e63ea4bb8ca01410cd4e71ddad34aa1f12c1387902b3d56634f89c619a2e6756648ab3bf90e9bc945afc9140eb935b633bae96bb067e9ee421697bcf80b14b1b88dbf13e010b472a7ca5411db36848b9c7a37f" ) == 0 );
12229  }
12230  }
12231  }
12232  FCT_TEST_END();
12233 
12234 
12235  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102432_1)
12236  {
12237  unsigned char key_str[128];
12238  unsigned char src_str[128];
12239  unsigned char dst_str[257];
12240  unsigned char iv_str[128];
12241  unsigned char add_str[128];
12242  unsigned char tag_str[128];
12243  unsigned char output[128];
12244  gcm_context ctx;
12245  unsigned int key_len;
12246  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
12247  int ret;
12248 
12249  memset(key_str, 0x00, 128);
12250  memset(src_str, 0x00, 128);
12251  memset(dst_str, 0x00, 257);
12252  memset(iv_str, 0x00, 128);
12253  memset(add_str, 0x00, 128);
12254  memset(tag_str, 0x00, 128);
12255  memset(output, 0x00, 128);
12256 
12257  key_len = unhexify( key_str, "3ed5dadefa0f6d14fedd1a3cdbab109f6660896a952ac5ab" );
12258  pt_len = unhexify( src_str, "aef617f69724e020309ec39d9587520efda68a8e303686c3a41ef700cba05b7c6e43e95aadb1a566f61650c87845835e789eb2366941e3bfef6d9846af0e0dbc43249117ad6f299bbc40669ac383cdf79289ada6ccd8ccfe329a0dc6a38eea1a99550457102d10f641cda50c21f533b1f981663f74a0a7c657c04d9fc6696ff4" );
12259  iv_len = unhexify( iv_str, "553a14f1e1619f9d7bd07cd823961f25" );
12260  add_len = unhexify( add_str, "eb8ea81d3e328a1113942cd5efd0f2b5e7f088791c8fc05690a34584101c4d493628ee7d0099a2865ac194b9124c3fb924de0c4428d0a1c26ea3ad9a0bc89187a16673e3b6f7e370dfb2dc26e8a56a9cf91f9c2088c020a766efe0d0c91689743a603f2cd1e300a6a84828b3b515a4b9a06e6bb20457bf124cd6ce4ac8b83d51" );
12261  unhexify( tag_str, "dc413c4c" );
12262 
12263  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12264  if( 0 == 0 )
12265  {
12266  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12267 
12268  if( strcmp( "FAIL", "bc1f34991a48aabb0fea513f790f0d223e9feac4c99fa1e8427f01ab8b4b2827cfaf239342de36051a846af0306a3f82e7aed98dd0416fb078bc7f3b617b00ceb2cea4ddafc22dd022efa8303e9804510e0e888065d8427345156d823f796f74130c06db9f9934435552b4fefd051953e20ecba3a4514ac121d7d2097d597439" ) == 0 )
12269  {
12270  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12271  }
12272  else
12273  {
12274  hexify( dst_str, output, pt_len );
12275 
12276  fct_chk( strcmp( (char *) dst_str, "bc1f34991a48aabb0fea513f790f0d223e9feac4c99fa1e8427f01ab8b4b2827cfaf239342de36051a846af0306a3f82e7aed98dd0416fb078bc7f3b617b00ceb2cea4ddafc22dd022efa8303e9804510e0e888065d8427345156d823f796f74130c06db9f9934435552b4fefd051953e20ecba3a4514ac121d7d2097d597439" ) == 0 );
12277  }
12278  }
12279  }
12280  FCT_TEST_END();
12281 
12282 
12283  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102432_2)
12284  {
12285  unsigned char key_str[128];
12286  unsigned char src_str[128];
12287  unsigned char dst_str[257];
12288  unsigned char iv_str[128];
12289  unsigned char add_str[128];
12290  unsigned char tag_str[128];
12291  unsigned char output[128];
12292  gcm_context ctx;
12293  unsigned int key_len;
12294  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
12295  int ret;
12296 
12297  memset(key_str, 0x00, 128);
12298  memset(src_str, 0x00, 128);
12299  memset(dst_str, 0x00, 257);
12300  memset(iv_str, 0x00, 128);
12301  memset(add_str, 0x00, 128);
12302  memset(tag_str, 0x00, 128);
12303  memset(output, 0x00, 128);
12304 
12305  key_len = unhexify( key_str, "6d97e8bff3923a778504fb917dbc1428a1328587047697d9" );
12306  pt_len = unhexify( src_str, "dc1a81efd51e967767f5bdd7e2e425732c1d28451f2bf5bdf3f5a6492279330594d360dd8a193e5dbde1be49bf143a35c38bcd059f762ada65c5119e097f0976891347f4d829b087bd72daa3494b344cbd3370c4459ca243bd57aeda4cb86cdd0bf274f07830cdbf5e5be4eb9b742ddffef8aa35626d2b9ea0a29d3c3d058b28" );
12307  iv_len = unhexify( iv_str, "0c28dc4cd53725091c2fb68a476c2e40" );
12308  add_len = unhexify( add_str, "f3932f5e82d75a1e3eba1591c17769e1a45819ccf057c31e76fa810b93678766d25905e859775c244e96bcafbc75c4a2d95e7d02868ccb2f65e49276f0b645ac8cf6e3758402304a3c25ce2de0a49f401b1acadaff8b57589b45cc79130ddc8387f41cc383e33ef38eec019152051c756198d6f782ccf56297b9fe944269a65a" );
12309  unhexify( tag_str, "e6d6df7a" );
12310 
12311  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12312  if( 0 == 0 )
12313  {
12314  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12315 
12316  if( strcmp( "FAIL", "39327836e9d8cfb59397adcf045a85644c52c3563290795811f26350c8bce8f55ca779cbcd15479efd8144b8a39ef611153955c70bf3a7da9d4d944c2407a0d735784fcb68de1083eebf6940ebc9cf92f9f139c01404b503ff64e61126a94e881351473507884357040fd32714b872c254349071069644e2bd642905521b944e" ) == 0 )
12317  {
12318  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12319  }
12320  else
12321  {
12322  hexify( dst_str, output, pt_len );
12323 
12324  fct_chk( strcmp( (char *) dst_str, "39327836e9d8cfb59397adcf045a85644c52c3563290795811f26350c8bce8f55ca779cbcd15479efd8144b8a39ef611153955c70bf3a7da9d4d944c2407a0d735784fcb68de1083eebf6940ebc9cf92f9f139c01404b503ff64e61126a94e881351473507884357040fd32714b872c254349071069644e2bd642905521b944e" ) == 0 );
12325  }
12326  }
12327  }
12328  FCT_TEST_END();
12329 
12330 
12331  FCT_TEST_BGN(gcm_nist_validation_aes_19212800128_0)
12332  {
12333  unsigned char key_str[128];
12334  unsigned char src_str[128];
12335  unsigned char dst_str[257];
12336  unsigned char iv_str[128];
12337  unsigned char add_str[128];
12338  unsigned char tag_str[128];
12339  unsigned char output[128];
12340  gcm_context ctx;
12341  unsigned int key_len;
12342  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
12343  int ret;
12344 
12345  memset(key_str, 0x00, 128);
12346  memset(src_str, 0x00, 128);
12347  memset(dst_str, 0x00, 257);
12348  memset(iv_str, 0x00, 128);
12349  memset(add_str, 0x00, 128);
12350  memset(tag_str, 0x00, 128);
12351  memset(output, 0x00, 128);
12352 
12353  key_len = unhexify( key_str, "2c78e29971e90a01bb65973f81260b9344fa835751f5f142" );
12354  pt_len = unhexify( src_str, "" );
12355  iv_len = unhexify( iv_str, "f1a23ce6e2bc9088a62c887abecd30ae" );
12356  add_len = unhexify( add_str, "" );
12357  unhexify( tag_str, "d4d5c22f993c8c610145fcbe4e021687" );
12358 
12359  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12360  if( 0 == 0 )
12361  {
12362  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12363 
12364  if( strcmp( "FAIL", "" ) == 0 )
12365  {
12366  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12367  }
12368  else
12369  {
12370  hexify( dst_str, output, pt_len );
12371 
12372  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
12373  }
12374  }
12375  }
12376  FCT_TEST_END();
12377 
12378 
12379  FCT_TEST_BGN(gcm_nist_validation_aes_19212800128_1)
12380  {
12381  unsigned char key_str[128];
12382  unsigned char src_str[128];
12383  unsigned char dst_str[257];
12384  unsigned char iv_str[128];
12385  unsigned char add_str[128];
12386  unsigned char tag_str[128];
12387  unsigned char output[128];
12388  gcm_context ctx;
12389  unsigned int key_len;
12390  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
12391  int ret;
12392 
12393  memset(key_str, 0x00, 128);
12394  memset(src_str, 0x00, 128);
12395  memset(dst_str, 0x00, 257);
12396  memset(iv_str, 0x00, 128);
12397  memset(add_str, 0x00, 128);
12398  memset(tag_str, 0x00, 128);
12399  memset(output, 0x00, 128);
12400 
12401  key_len = unhexify( key_str, "8c582d5b6a40ef0e4048ec20f0263572d7cc82704e380851" );
12402  pt_len = unhexify( src_str, "" );
12403  iv_len = unhexify( iv_str, "ef221a1c66fda17906190b7c99ab60b8" );
12404  add_len = unhexify( add_str, "" );
12405  unhexify( tag_str, "6327dcb46ffb3d0fd8fbf3d2848a8f01" );
12406 
12407  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12408  if( 0 == 0 )
12409  {
12410  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12411 
12412  if( strcmp( "FAIL", "" ) == 0 )
12413  {
12414  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12415  }
12416  else
12417  {
12418  hexify( dst_str, output, pt_len );
12419 
12420  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
12421  }
12422  }
12423  }
12424  FCT_TEST_END();
12425 
12426 
12427  FCT_TEST_BGN(gcm_nist_validation_aes_19212800128_2)
12428  {
12429  unsigned char key_str[128];
12430  unsigned char src_str[128];
12431  unsigned char dst_str[257];
12432  unsigned char iv_str[128];
12433  unsigned char add_str[128];
12434  unsigned char tag_str[128];
12435  unsigned char output[128];
12436  gcm_context ctx;
12437  unsigned int key_len;
12438  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
12439  int ret;
12440 
12441  memset(key_str, 0x00, 128);
12442  memset(src_str, 0x00, 128);
12443  memset(dst_str, 0x00, 257);
12444  memset(iv_str, 0x00, 128);
12445  memset(add_str, 0x00, 128);
12446  memset(tag_str, 0x00, 128);
12447  memset(output, 0x00, 128);
12448 
12449  key_len = unhexify( key_str, "3a58abadd29e946e23ca9eb09af059913d5394971bda6a4f" );
12450  pt_len = unhexify( src_str, "" );
12451  iv_len = unhexify( iv_str, "7c29b3196d44df78fa514a1967fcd3a6" );
12452  add_len = unhexify( add_str, "" );
12453  unhexify( tag_str, "fc123944bbea6c5075a5f987aed9cf99" );
12454 
12455  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12456  if( 0 == 0 )
12457  {
12458  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12459 
12460  if( strcmp( "FAIL", "FAIL" ) == 0 )
12461  {
12462  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12463  }
12464  else
12465  {
12466  hexify( dst_str, output, pt_len );
12467 
12468  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
12469  }
12470  }
12471  }
12472  FCT_TEST_END();
12473 
12474 
12475  FCT_TEST_BGN(gcm_nist_validation_aes_19212800120_0)
12476  {
12477  unsigned char key_str[128];
12478  unsigned char src_str[128];
12479  unsigned char dst_str[257];
12480  unsigned char iv_str[128];
12481  unsigned char add_str[128];
12482  unsigned char tag_str[128];
12483  unsigned char output[128];
12484  gcm_context ctx;
12485  unsigned int key_len;
12486  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
12487  int ret;
12488 
12489  memset(key_str, 0x00, 128);
12490  memset(src_str, 0x00, 128);
12491  memset(dst_str, 0x00, 257);
12492  memset(iv_str, 0x00, 128);
12493  memset(add_str, 0x00, 128);
12494  memset(tag_str, 0x00, 128);
12495  memset(output, 0x00, 128);
12496 
12497  key_len = unhexify( key_str, "04bdde4c35c385783715d8a883640851b860ce0e8436ec19" );
12498  pt_len = unhexify( src_str, "" );
12499  iv_len = unhexify( iv_str, "783f9a3c36b6d0c9fd57c15105316535" );
12500  add_len = unhexify( add_str, "" );
12501  unhexify( tag_str, "23e21a803cac5237777014686564f2" );
12502 
12503  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12504  if( 0 == 0 )
12505  {
12506  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12507 
12508  if( strcmp( "FAIL", "" ) == 0 )
12509  {
12510  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12511  }
12512  else
12513  {
12514  hexify( dst_str, output, pt_len );
12515 
12516  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
12517  }
12518  }
12519  }
12520  FCT_TEST_END();
12521 
12522 
12523  FCT_TEST_BGN(gcm_nist_validation_aes_19212800120_1)
12524  {
12525  unsigned char key_str[128];
12526  unsigned char src_str[128];
12527  unsigned char dst_str[257];
12528  unsigned char iv_str[128];
12529  unsigned char add_str[128];
12530  unsigned char tag_str[128];
12531  unsigned char output[128];
12532  gcm_context ctx;
12533  unsigned int key_len;
12534  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
12535  int ret;
12536 
12537  memset(key_str, 0x00, 128);
12538  memset(src_str, 0x00, 128);
12539  memset(dst_str, 0x00, 257);
12540  memset(iv_str, 0x00, 128);
12541  memset(add_str, 0x00, 128);
12542  memset(tag_str, 0x00, 128);
12543  memset(output, 0x00, 128);
12544 
12545  key_len = unhexify( key_str, "4ba5fba0c22fbe10c2d1690c5d99938522de9c5186721bac" );
12546  pt_len = unhexify( src_str, "" );
12547  iv_len = unhexify( iv_str, "2acc2073089a34d4651eee39a262e8ae" );
12548  add_len = unhexify( add_str, "" );
12549  unhexify( tag_str, "7ac742c859a02a543b50464c66dcf5" );
12550 
12551  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12552  if( 0 == 0 )
12553  {
12554  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12555 
12556  if( strcmp( "FAIL", "" ) == 0 )
12557  {
12558  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12559  }
12560  else
12561  {
12562  hexify( dst_str, output, pt_len );
12563 
12564  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
12565  }
12566  }
12567  }
12568  FCT_TEST_END();
12569 
12570 
12571  FCT_TEST_BGN(gcm_nist_validation_aes_19212800120_2)
12572  {
12573  unsigned char key_str[128];
12574  unsigned char src_str[128];
12575  unsigned char dst_str[257];
12576  unsigned char iv_str[128];
12577  unsigned char add_str[128];
12578  unsigned char tag_str[128];
12579  unsigned char output[128];
12580  gcm_context ctx;
12581  unsigned int key_len;
12582  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
12583  int ret;
12584 
12585  memset(key_str, 0x00, 128);
12586  memset(src_str, 0x00, 128);
12587  memset(dst_str, 0x00, 257);
12588  memset(iv_str, 0x00, 128);
12589  memset(add_str, 0x00, 128);
12590  memset(tag_str, 0x00, 128);
12591  memset(output, 0x00, 128);
12592 
12593  key_len = unhexify( key_str, "f12890b0a8819faa5a8e0e487f7f064af42fa6d5519d009f" );
12594  pt_len = unhexify( src_str, "" );
12595  iv_len = unhexify( iv_str, "c937615675738f4b3227c799833d1e61" );
12596  add_len = unhexify( add_str, "" );
12597  unhexify( tag_str, "88300bd65b12dcb341f1f6d8a15584" );
12598 
12599  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12600  if( 0 == 0 )
12601  {
12602  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12603 
12604  if( strcmp( "FAIL", "FAIL" ) == 0 )
12605  {
12606  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12607  }
12608  else
12609  {
12610  hexify( dst_str, output, pt_len );
12611 
12612  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
12613  }
12614  }
12615  }
12616  FCT_TEST_END();
12617 
12618 
12619  FCT_TEST_BGN(gcm_nist_validation_aes_19212800112_0)
12620  {
12621  unsigned char key_str[128];
12622  unsigned char src_str[128];
12623  unsigned char dst_str[257];
12624  unsigned char iv_str[128];
12625  unsigned char add_str[128];
12626  unsigned char tag_str[128];
12627  unsigned char output[128];
12628  gcm_context ctx;
12629  unsigned int key_len;
12630  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
12631  int ret;
12632 
12633  memset(key_str, 0x00, 128);
12634  memset(src_str, 0x00, 128);
12635  memset(dst_str, 0x00, 257);
12636  memset(iv_str, 0x00, 128);
12637  memset(add_str, 0x00, 128);
12638  memset(tag_str, 0x00, 128);
12639  memset(output, 0x00, 128);
12640 
12641  key_len = unhexify( key_str, "51878f3630298a81297f4a21514fea637faa3815d4f26fae" );
12642  pt_len = unhexify( src_str, "" );
12643  iv_len = unhexify( iv_str, "1f939226feab012dabfc2193637d15b1" );
12644  add_len = unhexify( add_str, "" );
12645  unhexify( tag_str, "eed5fcb7607c038b354746d91c5b" );
12646 
12647  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12648  if( 0 == 0 )
12649  {
12650  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12651 
12652  if( strcmp( "FAIL", "FAIL" ) == 0 )
12653  {
12654  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12655  }
12656  else
12657  {
12658  hexify( dst_str, output, pt_len );
12659 
12660  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
12661  }
12662  }
12663  }
12664  FCT_TEST_END();
12665 
12666 
12667  FCT_TEST_BGN(gcm_nist_validation_aes_19212800112_1)
12668  {
12669  unsigned char key_str[128];
12670  unsigned char src_str[128];
12671  unsigned char dst_str[257];
12672  unsigned char iv_str[128];
12673  unsigned char add_str[128];
12674  unsigned char tag_str[128];
12675  unsigned char output[128];
12676  gcm_context ctx;
12677  unsigned int key_len;
12678  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
12679  int ret;
12680 
12681  memset(key_str, 0x00, 128);
12682  memset(src_str, 0x00, 128);
12683  memset(dst_str, 0x00, 257);
12684  memset(iv_str, 0x00, 128);
12685  memset(add_str, 0x00, 128);
12686  memset(tag_str, 0x00, 128);
12687  memset(output, 0x00, 128);
12688 
12689  key_len = unhexify( key_str, "ae596e74840a600556a06f97b13b89e38f67c152f1a1b930" );
12690  pt_len = unhexify( src_str, "" );
12691  iv_len = unhexify( iv_str, "e2076e1050070d468659885ea77e88d0" );
12692  add_len = unhexify( add_str, "" );
12693  unhexify( tag_str, "b4586bdbd4b6b899648f2333eee0" );
12694 
12695  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12696  if( 0 == 0 )
12697  {
12698  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12699 
12700  if( strcmp( "FAIL", "" ) == 0 )
12701  {
12702  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12703  }
12704  else
12705  {
12706  hexify( dst_str, output, pt_len );
12707 
12708  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
12709  }
12710  }
12711  }
12712  FCT_TEST_END();
12713 
12714 
12715  FCT_TEST_BGN(gcm_nist_validation_aes_19212800112_2)
12716  {
12717  unsigned char key_str[128];
12718  unsigned char src_str[128];
12719  unsigned char dst_str[257];
12720  unsigned char iv_str[128];
12721  unsigned char add_str[128];
12722  unsigned char tag_str[128];
12723  unsigned char output[128];
12724  gcm_context ctx;
12725  unsigned int key_len;
12726  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
12727  int ret;
12728 
12729  memset(key_str, 0x00, 128);
12730  memset(src_str, 0x00, 128);
12731  memset(dst_str, 0x00, 257);
12732  memset(iv_str, 0x00, 128);
12733  memset(add_str, 0x00, 128);
12734  memset(tag_str, 0x00, 128);
12735  memset(output, 0x00, 128);
12736 
12737  key_len = unhexify( key_str, "fd33b7a0efae34339ca987b5eb8075385fd1276e63cc8530" );
12738  pt_len = unhexify( src_str, "" );
12739  iv_len = unhexify( iv_str, "2d07bb8616fc0bbb71755a1bd256e7fb" );
12740  add_len = unhexify( add_str, "" );
12741  unhexify( tag_str, "6b60d645220cfde42d88296ac193" );
12742 
12743  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12744  if( 0 == 0 )
12745  {
12746  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12747 
12748  if( strcmp( "FAIL", "FAIL" ) == 0 )
12749  {
12750  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12751  }
12752  else
12753  {
12754  hexify( dst_str, output, pt_len );
12755 
12756  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
12757  }
12758  }
12759  }
12760  FCT_TEST_END();
12761 
12762 
12763  FCT_TEST_BGN(gcm_nist_validation_aes_19212800104_0)
12764  {
12765  unsigned char key_str[128];
12766  unsigned char src_str[128];
12767  unsigned char dst_str[257];
12768  unsigned char iv_str[128];
12769  unsigned char add_str[128];
12770  unsigned char tag_str[128];
12771  unsigned char output[128];
12772  gcm_context ctx;
12773  unsigned int key_len;
12774  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
12775  int ret;
12776 
12777  memset(key_str, 0x00, 128);
12778  memset(src_str, 0x00, 128);
12779  memset(dst_str, 0x00, 257);
12780  memset(iv_str, 0x00, 128);
12781  memset(add_str, 0x00, 128);
12782  memset(tag_str, 0x00, 128);
12783  memset(output, 0x00, 128);
12784 
12785  key_len = unhexify( key_str, "5685b12a6617d554c36b62af5b8ff2239cb3ffb1d2c40e14" );
12786  pt_len = unhexify( src_str, "" );
12787  iv_len = unhexify( iv_str, "6c31194df99d08881fa5b1dd33b45a92" );
12788  add_len = unhexify( add_str, "" );
12789  unhexify( tag_str, "69431593c376c9f8052bf10747" );
12790 
12791  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12792  if( 0 == 0 )
12793  {
12794  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12795 
12796  if( strcmp( "FAIL", "FAIL" ) == 0 )
12797  {
12798  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12799  }
12800  else
12801  {
12802  hexify( dst_str, output, pt_len );
12803 
12804  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
12805  }
12806  }
12807  }
12808  FCT_TEST_END();
12809 
12810 
12811  FCT_TEST_BGN(gcm_nist_validation_aes_19212800104_1)
12812  {
12813  unsigned char key_str[128];
12814  unsigned char src_str[128];
12815  unsigned char dst_str[257];
12816  unsigned char iv_str[128];
12817  unsigned char add_str[128];
12818  unsigned char tag_str[128];
12819  unsigned char output[128];
12820  gcm_context ctx;
12821  unsigned int key_len;
12822  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
12823  int ret;
12824 
12825  memset(key_str, 0x00, 128);
12826  memset(src_str, 0x00, 128);
12827  memset(dst_str, 0x00, 257);
12828  memset(iv_str, 0x00, 128);
12829  memset(add_str, 0x00, 128);
12830  memset(tag_str, 0x00, 128);
12831  memset(output, 0x00, 128);
12832 
12833  key_len = unhexify( key_str, "036ae037410dae9f0741608516d03b855c9c1851df8c54a4" );
12834  pt_len = unhexify( src_str, "" );
12835  iv_len = unhexify( iv_str, "73599275f8237f14c4a52b283c07275d" );
12836  add_len = unhexify( add_str, "" );
12837  unhexify( tag_str, "6f7249d25c9f273434c4720275" );
12838 
12839  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12840  if( 0 == 0 )
12841  {
12842  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12843 
12844  if( strcmp( "FAIL", "" ) == 0 )
12845  {
12846  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12847  }
12848  else
12849  {
12850  hexify( dst_str, output, pt_len );
12851 
12852  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
12853  }
12854  }
12855  }
12856  FCT_TEST_END();
12857 
12858 
12859  FCT_TEST_BGN(gcm_nist_validation_aes_19212800104_2)
12860  {
12861  unsigned char key_str[128];
12862  unsigned char src_str[128];
12863  unsigned char dst_str[257];
12864  unsigned char iv_str[128];
12865  unsigned char add_str[128];
12866  unsigned char tag_str[128];
12867  unsigned char output[128];
12868  gcm_context ctx;
12869  unsigned int key_len;
12870  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
12871  int ret;
12872 
12873  memset(key_str, 0x00, 128);
12874  memset(src_str, 0x00, 128);
12875  memset(dst_str, 0x00, 257);
12876  memset(iv_str, 0x00, 128);
12877  memset(add_str, 0x00, 128);
12878  memset(tag_str, 0x00, 128);
12879  memset(output, 0x00, 128);
12880 
12881  key_len = unhexify( key_str, "ac144f39ebd6124bad85c9c7fb4f75bff389ece2e8085d83" );
12882  pt_len = unhexify( src_str, "" );
12883  iv_len = unhexify( iv_str, "d0871bfc3693245be478e6a257c79efb" );
12884  add_len = unhexify( add_str, "" );
12885  unhexify( tag_str, "5a99d59631d0e12f58b7b95ccd" );
12886 
12887  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12888  if( 0 == 0 )
12889  {
12890  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12891 
12892  if( strcmp( "FAIL", "FAIL" ) == 0 )
12893  {
12894  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12895  }
12896  else
12897  {
12898  hexify( dst_str, output, pt_len );
12899 
12900  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
12901  }
12902  }
12903  }
12904  FCT_TEST_END();
12905 
12906 
12907  FCT_TEST_BGN(gcm_nist_validation_aes_1921280096_0)
12908  {
12909  unsigned char key_str[128];
12910  unsigned char src_str[128];
12911  unsigned char dst_str[257];
12912  unsigned char iv_str[128];
12913  unsigned char add_str[128];
12914  unsigned char tag_str[128];
12915  unsigned char output[128];
12916  gcm_context ctx;
12917  unsigned int key_len;
12918  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
12919  int ret;
12920 
12921  memset(key_str, 0x00, 128);
12922  memset(src_str, 0x00, 128);
12923  memset(dst_str, 0x00, 257);
12924  memset(iv_str, 0x00, 128);
12925  memset(add_str, 0x00, 128);
12926  memset(tag_str, 0x00, 128);
12927  memset(output, 0x00, 128);
12928 
12929  key_len = unhexify( key_str, "a8a541ff11a1b8548e832d9e015edeccc94b87dadc156065" );
12930  pt_len = unhexify( src_str, "" );
12931  iv_len = unhexify( iv_str, "c72bb300b624c27cded863eba56e7587" );
12932  add_len = unhexify( add_str, "" );
12933  unhexify( tag_str, "ea2528e7439be2ed0a0d6b2a" );
12934 
12935  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12936  if( 0 == 0 )
12937  {
12938  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12939 
12940  if( strcmp( "FAIL", "" ) == 0 )
12941  {
12942  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12943  }
12944  else
12945  {
12946  hexify( dst_str, output, pt_len );
12947 
12948  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
12949  }
12950  }
12951  }
12952  FCT_TEST_END();
12953 
12954 
12955  FCT_TEST_BGN(gcm_nist_validation_aes_1921280096_1)
12956  {
12957  unsigned char key_str[128];
12958  unsigned char src_str[128];
12959  unsigned char dst_str[257];
12960  unsigned char iv_str[128];
12961  unsigned char add_str[128];
12962  unsigned char tag_str[128];
12963  unsigned char output[128];
12964  gcm_context ctx;
12965  unsigned int key_len;
12966  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
12967  int ret;
12968 
12969  memset(key_str, 0x00, 128);
12970  memset(src_str, 0x00, 128);
12971  memset(dst_str, 0x00, 257);
12972  memset(iv_str, 0x00, 128);
12973  memset(add_str, 0x00, 128);
12974  memset(tag_str, 0x00, 128);
12975  memset(output, 0x00, 128);
12976 
12977  key_len = unhexify( key_str, "30dd8f400335e9c688e13cc0b1007bd21736a6d395d152e2" );
12978  pt_len = unhexify( src_str, "" );
12979  iv_len = unhexify( iv_str, "28899601fa95f532b030f11bbeb87011" );
12980  add_len = unhexify( add_str, "" );
12981  unhexify( tag_str, "35625638589bb7f6ccdb0222" );
12982 
12983  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
12984  if( 0 == 0 )
12985  {
12986  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
12987 
12988  if( strcmp( "FAIL", "" ) == 0 )
12989  {
12990  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
12991  }
12992  else
12993  {
12994  hexify( dst_str, output, pt_len );
12995 
12996  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
12997  }
12998  }
12999  }
13000  FCT_TEST_END();
13001 
13002 
13003  FCT_TEST_BGN(gcm_nist_validation_aes_1921280096_2)
13004  {
13005  unsigned char key_str[128];
13006  unsigned char src_str[128];
13007  unsigned char dst_str[257];
13008  unsigned char iv_str[128];
13009  unsigned char add_str[128];
13010  unsigned char tag_str[128];
13011  unsigned char output[128];
13012  gcm_context ctx;
13013  unsigned int key_len;
13014  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
13015  int ret;
13016 
13017  memset(key_str, 0x00, 128);
13018  memset(src_str, 0x00, 128);
13019  memset(dst_str, 0x00, 257);
13020  memset(iv_str, 0x00, 128);
13021  memset(add_str, 0x00, 128);
13022  memset(tag_str, 0x00, 128);
13023  memset(output, 0x00, 128);
13024 
13025  key_len = unhexify( key_str, "cb8f672b04d706d7d4125d6830fff5d2ec069569bea050ce" );
13026  pt_len = unhexify( src_str, "" );
13027  iv_len = unhexify( iv_str, "375d4134e8649367f4db9bdb07aa8594" );
13028  add_len = unhexify( add_str, "" );
13029  unhexify( tag_str, "70610bf329683e15ecf8c79f" );
13030 
13031  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13032  if( 0 == 0 )
13033  {
13034  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13035 
13036  if( strcmp( "FAIL", "FAIL" ) == 0 )
13037  {
13038  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13039  }
13040  else
13041  {
13042  hexify( dst_str, output, pt_len );
13043 
13044  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
13045  }
13046  }
13047  }
13048  FCT_TEST_END();
13049 
13050 
13051  FCT_TEST_BGN(gcm_nist_validation_aes_1921280064_0)
13052  {
13053  unsigned char key_str[128];
13054  unsigned char src_str[128];
13055  unsigned char dst_str[257];
13056  unsigned char iv_str[128];
13057  unsigned char add_str[128];
13058  unsigned char tag_str[128];
13059  unsigned char output[128];
13060  gcm_context ctx;
13061  unsigned int key_len;
13062  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
13063  int ret;
13064 
13065  memset(key_str, 0x00, 128);
13066  memset(src_str, 0x00, 128);
13067  memset(dst_str, 0x00, 257);
13068  memset(iv_str, 0x00, 128);
13069  memset(add_str, 0x00, 128);
13070  memset(tag_str, 0x00, 128);
13071  memset(output, 0x00, 128);
13072 
13073  key_len = unhexify( key_str, "bf71e5b1cd6eb363ecd89a4958675a1166c10749e1ff1f44" );
13074  pt_len = unhexify( src_str, "" );
13075  iv_len = unhexify( iv_str, "9f502fb5ac90ff5f5616dd1fa837387d" );
13076  add_len = unhexify( add_str, "" );
13077  unhexify( tag_str, "a4b5138122e1209d" );
13078 
13079  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13080  if( 0 == 0 )
13081  {
13082  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13083 
13084  if( strcmp( "FAIL", "FAIL" ) == 0 )
13085  {
13086  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13087  }
13088  else
13089  {
13090  hexify( dst_str, output, pt_len );
13091 
13092  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
13093  }
13094  }
13095  }
13096  FCT_TEST_END();
13097 
13098 
13099  FCT_TEST_BGN(gcm_nist_validation_aes_1921280064_1)
13100  {
13101  unsigned char key_str[128];
13102  unsigned char src_str[128];
13103  unsigned char dst_str[257];
13104  unsigned char iv_str[128];
13105  unsigned char add_str[128];
13106  unsigned char tag_str[128];
13107  unsigned char output[128];
13108  gcm_context ctx;
13109  unsigned int key_len;
13110  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
13111  int ret;
13112 
13113  memset(key_str, 0x00, 128);
13114  memset(src_str, 0x00, 128);
13115  memset(dst_str, 0x00, 257);
13116  memset(iv_str, 0x00, 128);
13117  memset(add_str, 0x00, 128);
13118  memset(tag_str, 0x00, 128);
13119  memset(output, 0x00, 128);
13120 
13121  key_len = unhexify( key_str, "5b9d1dfb2303b66848e363793bdca0e5ada8599cb2c09e24" );
13122  pt_len = unhexify( src_str, "" );
13123  iv_len = unhexify( iv_str, "2ee96384dd29f8a4c4a6102549a026ab" );
13124  add_len = unhexify( add_str, "" );
13125  unhexify( tag_str, "3b33a10189338c3b" );
13126 
13127  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13128  if( 0 == 0 )
13129  {
13130  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13131 
13132  if( strcmp( "FAIL", "FAIL" ) == 0 )
13133  {
13134  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13135  }
13136  else
13137  {
13138  hexify( dst_str, output, pt_len );
13139 
13140  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
13141  }
13142  }
13143  }
13144  FCT_TEST_END();
13145 
13146 
13147  FCT_TEST_BGN(gcm_nist_validation_aes_1921280064_2)
13148  {
13149  unsigned char key_str[128];
13150  unsigned char src_str[128];
13151  unsigned char dst_str[257];
13152  unsigned char iv_str[128];
13153  unsigned char add_str[128];
13154  unsigned char tag_str[128];
13155  unsigned char output[128];
13156  gcm_context ctx;
13157  unsigned int key_len;
13158  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
13159  int ret;
13160 
13161  memset(key_str, 0x00, 128);
13162  memset(src_str, 0x00, 128);
13163  memset(dst_str, 0x00, 257);
13164  memset(iv_str, 0x00, 128);
13165  memset(add_str, 0x00, 128);
13166  memset(tag_str, 0x00, 128);
13167  memset(output, 0x00, 128);
13168 
13169  key_len = unhexify( key_str, "a35ae271f70ebacb28173b37b921f5abcad1712a1cf5d5db" );
13170  pt_len = unhexify( src_str, "" );
13171  iv_len = unhexify( iv_str, "8d97f354564d8185b57f7727626850a0" );
13172  add_len = unhexify( add_str, "" );
13173  unhexify( tag_str, "813d2f98a760130c" );
13174 
13175  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13176  if( 0 == 0 )
13177  {
13178  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13179 
13180  if( strcmp( "FAIL", "" ) == 0 )
13181  {
13182  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13183  }
13184  else
13185  {
13186  hexify( dst_str, output, pt_len );
13187 
13188  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13189  }
13190  }
13191  }
13192  FCT_TEST_END();
13193 
13194 
13195  FCT_TEST_BGN(gcm_nist_validation_aes_1921280032_0)
13196  {
13197  unsigned char key_str[128];
13198  unsigned char src_str[128];
13199  unsigned char dst_str[257];
13200  unsigned char iv_str[128];
13201  unsigned char add_str[128];
13202  unsigned char tag_str[128];
13203  unsigned char output[128];
13204  gcm_context ctx;
13205  unsigned int key_len;
13206  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
13207  int ret;
13208 
13209  memset(key_str, 0x00, 128);
13210  memset(src_str, 0x00, 128);
13211  memset(dst_str, 0x00, 257);
13212  memset(iv_str, 0x00, 128);
13213  memset(add_str, 0x00, 128);
13214  memset(tag_str, 0x00, 128);
13215  memset(output, 0x00, 128);
13216 
13217  key_len = unhexify( key_str, "9bdd0cb826d5d28c2ab9777d5a0c1558e7c8227c53ed4c4f" );
13218  pt_len = unhexify( src_str, "" );
13219  iv_len = unhexify( iv_str, "daf13501a47ee73c0197d8b774eec399" );
13220  add_len = unhexify( add_str, "" );
13221  unhexify( tag_str, "a6d108c0" );
13222 
13223  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13224  if( 0 == 0 )
13225  {
13226  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13227 
13228  if( strcmp( "FAIL", "" ) == 0 )
13229  {
13230  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13231  }
13232  else
13233  {
13234  hexify( dst_str, output, pt_len );
13235 
13236  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13237  }
13238  }
13239  }
13240  FCT_TEST_END();
13241 
13242 
13243  FCT_TEST_BGN(gcm_nist_validation_aes_1921280032_1)
13244  {
13245  unsigned char key_str[128];
13246  unsigned char src_str[128];
13247  unsigned char dst_str[257];
13248  unsigned char iv_str[128];
13249  unsigned char add_str[128];
13250  unsigned char tag_str[128];
13251  unsigned char output[128];
13252  gcm_context ctx;
13253  unsigned int key_len;
13254  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
13255  int ret;
13256 
13257  memset(key_str, 0x00, 128);
13258  memset(src_str, 0x00, 128);
13259  memset(dst_str, 0x00, 257);
13260  memset(iv_str, 0x00, 128);
13261  memset(add_str, 0x00, 128);
13262  memset(tag_str, 0x00, 128);
13263  memset(output, 0x00, 128);
13264 
13265  key_len = unhexify( key_str, "81b4d5ee4e1cbee1d8966fb3946409e6e64319a4b83231f5" );
13266  pt_len = unhexify( src_str, "" );
13267  iv_len = unhexify( iv_str, "bc2f9320d6b62eea29ebc9cf7fc9f04a" );
13268  add_len = unhexify( add_str, "" );
13269  unhexify( tag_str, "a47cdadd" );
13270 
13271  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13272  if( 0 == 0 )
13273  {
13274  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13275 
13276  if( strcmp( "FAIL", "" ) == 0 )
13277  {
13278  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13279  }
13280  else
13281  {
13282  hexify( dst_str, output, pt_len );
13283 
13284  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13285  }
13286  }
13287  }
13288  FCT_TEST_END();
13289 
13290 
13291  FCT_TEST_BGN(gcm_nist_validation_aes_1921280032_2)
13292  {
13293  unsigned char key_str[128];
13294  unsigned char src_str[128];
13295  unsigned char dst_str[257];
13296  unsigned char iv_str[128];
13297  unsigned char add_str[128];
13298  unsigned char tag_str[128];
13299  unsigned char output[128];
13300  gcm_context ctx;
13301  unsigned int key_len;
13302  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
13303  int ret;
13304 
13305  memset(key_str, 0x00, 128);
13306  memset(src_str, 0x00, 128);
13307  memset(dst_str, 0x00, 257);
13308  memset(iv_str, 0x00, 128);
13309  memset(add_str, 0x00, 128);
13310  memset(tag_str, 0x00, 128);
13311  memset(output, 0x00, 128);
13312 
13313  key_len = unhexify( key_str, "5813627d26d568dfe5a0f8184cf561fe455eb98b98841fe0" );
13314  pt_len = unhexify( src_str, "" );
13315  iv_len = unhexify( iv_str, "817199254a912880405c9729d75ed391" );
13316  add_len = unhexify( add_str, "" );
13317  unhexify( tag_str, "d81d9b41" );
13318 
13319  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13320  if( 0 == 0 )
13321  {
13322  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13323 
13324  if( strcmp( "FAIL", "" ) == 0 )
13325  {
13326  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13327  }
13328  else
13329  {
13330  hexify( dst_str, output, pt_len );
13331 
13332  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13333  }
13334  }
13335  }
13336  FCT_TEST_END();
13337 
13338 
13339  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024128_0)
13340  {
13341  unsigned char key_str[128];
13342  unsigned char src_str[128];
13343  unsigned char dst_str[257];
13344  unsigned char iv_str[128];
13345  unsigned char add_str[128];
13346  unsigned char tag_str[128];
13347  unsigned char output[128];
13348  gcm_context ctx;
13349  unsigned int key_len;
13350  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
13351  int ret;
13352 
13353  memset(key_str, 0x00, 128);
13354  memset(src_str, 0x00, 128);
13355  memset(dst_str, 0x00, 257);
13356  memset(iv_str, 0x00, 128);
13357  memset(add_str, 0x00, 128);
13358  memset(tag_str, 0x00, 128);
13359  memset(output, 0x00, 128);
13360 
13361  key_len = unhexify( key_str, "94f160e2325da2330fbe4e15910d33c2014f01ace58e5b24" );
13362  pt_len = unhexify( src_str, "" );
13363  iv_len = unhexify( iv_str, "80a1b99750980bf2be84a17032fc2721" );
13364  add_len = unhexify( add_str, "066fdd980cf043a732403ee5f65c82ca81e3fc858ad3cfa343014a8426fd3806770f127e2041efb42e31506ce83390ac5d76de2fe1806df24ce6e4bb894972a107ef99e51e4acfb0e325ab053f9824514b5941ab1ec598fbb57a5d18ed34d72992a19215d914e34ad1a22326e493d1ff2da7bc271c96ad3ab66d0c32bd711293" );
13365  unhexify( tag_str, "dd153cfd7aa946280660c445f586fa28" );
13366 
13367  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13368  if( 0 == 0 )
13369  {
13370  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13371 
13372  if( strcmp( "FAIL", "FAIL" ) == 0 )
13373  {
13374  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13375  }
13376  else
13377  {
13378  hexify( dst_str, output, pt_len );
13379 
13380  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
13381  }
13382  }
13383  }
13384  FCT_TEST_END();
13385 
13386 
13387  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024128_1)
13388  {
13389  unsigned char key_str[128];
13390  unsigned char src_str[128];
13391  unsigned char dst_str[257];
13392  unsigned char iv_str[128];
13393  unsigned char add_str[128];
13394  unsigned char tag_str[128];
13395  unsigned char output[128];
13396  gcm_context ctx;
13397  unsigned int key_len;
13398  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
13399  int ret;
13400 
13401  memset(key_str, 0x00, 128);
13402  memset(src_str, 0x00, 128);
13403  memset(dst_str, 0x00, 257);
13404  memset(iv_str, 0x00, 128);
13405  memset(add_str, 0x00, 128);
13406  memset(tag_str, 0x00, 128);
13407  memset(output, 0x00, 128);
13408 
13409  key_len = unhexify( key_str, "4785846f7c0524e78f3eb137fd433e1808af64549af69183" );
13410  pt_len = unhexify( src_str, "" );
13411  iv_len = unhexify( iv_str, "5334476a5fa3fa50dcc4b12f8ac00b51" );
13412  add_len = unhexify( add_str, "e70f82d1e3361ac5a5c9a087e47984d5533ba296f9b7e4a192a4ab28a833cdbbd5cece3415cf6fbb2f8055560b5c31c98d83d139954e1c03a464739f1eb5ad982c4371cf20b8984bbd97d5f40b336f5e96df3d272b95f7547be15c3bc05b3caac7d08c5eb5de8bdd246e74f6caa6bff76ea0417730ce72b911867f88fdcf73a0" );
13413  unhexify( tag_str, "c59231ddaae98e0e8db6b3fe8f4d3427" );
13414 
13415  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13416  if( 0 == 0 )
13417  {
13418  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13419 
13420  if( strcmp( "FAIL", "" ) == 0 )
13421  {
13422  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13423  }
13424  else
13425  {
13426  hexify( dst_str, output, pt_len );
13427 
13428  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13429  }
13430  }
13431  }
13432  FCT_TEST_END();
13433 
13434 
13435  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024128_2)
13436  {
13437  unsigned char key_str[128];
13438  unsigned char src_str[128];
13439  unsigned char dst_str[257];
13440  unsigned char iv_str[128];
13441  unsigned char add_str[128];
13442  unsigned char tag_str[128];
13443  unsigned char output[128];
13444  gcm_context ctx;
13445  unsigned int key_len;
13446  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
13447  int ret;
13448 
13449  memset(key_str, 0x00, 128);
13450  memset(src_str, 0x00, 128);
13451  memset(dst_str, 0x00, 257);
13452  memset(iv_str, 0x00, 128);
13453  memset(add_str, 0x00, 128);
13454  memset(tag_str, 0x00, 128);
13455  memset(output, 0x00, 128);
13456 
13457  key_len = unhexify( key_str, "49b085fe1a8e1ae769ed09fc585d29eb24d589689992e6c5" );
13458  pt_len = unhexify( src_str, "" );
13459  iv_len = unhexify( iv_str, "899878b0684fb865d30190821817b88c" );
13460  add_len = unhexify( add_str, "f789eafe3d02826b619ca4fbca7bb1919e5c6f7c33824a2f7f815dc50e329979705f7ef61e9adf7899d34f1b8840384ff62ef6d29eea38c45d12be9249aca69a02222cd744d81958c6816304ff0d81d6714a2023b3dd9d940db5c50afd89c52774d28d6afde2b6c68425b6acbe34682531a2e57e2b9a7729b3e8d96a729b15cc" );
13461  unhexify( tag_str, "2c84bf7a8947ab93b10ae408243b4993" );
13462 
13463  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13464  if( 0 == 0 )
13465  {
13466  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13467 
13468  if( strcmp( "FAIL", "" ) == 0 )
13469  {
13470  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13471  }
13472  else
13473  {
13474  hexify( dst_str, output, pt_len );
13475 
13476  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13477  }
13478  }
13479  }
13480  FCT_TEST_END();
13481 
13482 
13483  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024120_0)
13484  {
13485  unsigned char key_str[128];
13486  unsigned char src_str[128];
13487  unsigned char dst_str[257];
13488  unsigned char iv_str[128];
13489  unsigned char add_str[128];
13490  unsigned char tag_str[128];
13491  unsigned char output[128];
13492  gcm_context ctx;
13493  unsigned int key_len;
13494  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
13495  int ret;
13496 
13497  memset(key_str, 0x00, 128);
13498  memset(src_str, 0x00, 128);
13499  memset(dst_str, 0x00, 257);
13500  memset(iv_str, 0x00, 128);
13501  memset(add_str, 0x00, 128);
13502  memset(tag_str, 0x00, 128);
13503  memset(output, 0x00, 128);
13504 
13505  key_len = unhexify( key_str, "75847588760ecb6ca548747b743914c89fea367a5ccb81b6" );
13506  pt_len = unhexify( src_str, "" );
13507  iv_len = unhexify( iv_str, "7d8a9fd254e2061c01e39eb574951924" );
13508  add_len = unhexify( add_str, "b03c57dfd49152401a225357f1d6e533f3a423e5cfce07b8ae7ca9daf68645e5bd67b3ca2421eac447530b27c6dc6bd9c7f1b22441b8cc8c4ac26cec2c9c0d665a35b66d779a3772d714f802d6b6272984808d0740344b6abdb63e626ef4e1ab0469da521c7908b2c95a0fd07437c0e9d4d2451ae189ad61ff19f4efb405127c" );
13509  unhexify( tag_str, "e8aac14b53cdbc2028d330fc8d92a7" );
13510 
13511  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13512  if( 0 == 0 )
13513  {
13514  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13515 
13516  if( strcmp( "FAIL", "" ) == 0 )
13517  {
13518  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13519  }
13520  else
13521  {
13522  hexify( dst_str, output, pt_len );
13523 
13524  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13525  }
13526  }
13527  }
13528  FCT_TEST_END();
13529 
13530 
13531  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024120_1)
13532  {
13533  unsigned char key_str[128];
13534  unsigned char src_str[128];
13535  unsigned char dst_str[257];
13536  unsigned char iv_str[128];
13537  unsigned char add_str[128];
13538  unsigned char tag_str[128];
13539  unsigned char output[128];
13540  gcm_context ctx;
13541  unsigned int key_len;
13542  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
13543  int ret;
13544 
13545  memset(key_str, 0x00, 128);
13546  memset(src_str, 0x00, 128);
13547  memset(dst_str, 0x00, 257);
13548  memset(iv_str, 0x00, 128);
13549  memset(add_str, 0x00, 128);
13550  memset(tag_str, 0x00, 128);
13551  memset(output, 0x00, 128);
13552 
13553  key_len = unhexify( key_str, "e3a18a96d2e45d2f60780dc39cee7160e28cb810bf09858c" );
13554  pt_len = unhexify( src_str, "" );
13555  iv_len = unhexify( iv_str, "26a4d659665ded39b7a1583de756d0ad" );
13556  add_len = unhexify( add_str, "83f8d9c58169b4c68032321197077ff5c8ee4ebb732b040748e1b55dcf53375ae86fb9646a672b5c5bc805a92c475cbb6d0ed689a58abdf2230250a7d3fbd8cfab07835fa85e738a7f74bc3e93616d844b1ec61b79f23dfea62e1815f295d43f61d7b5956103b31ca88afb0b3d37eb42cf77232dbf2258065232971c397dcbcb" );
13557  unhexify( tag_str, "dc034564d4be7de243ff059b5f9160" );
13558 
13559  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13560  if( 0 == 0 )
13561  {
13562  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13563 
13564  if( strcmp( "FAIL", "FAIL" ) == 0 )
13565  {
13566  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13567  }
13568  else
13569  {
13570  hexify( dst_str, output, pt_len );
13571 
13572  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
13573  }
13574  }
13575  }
13576  FCT_TEST_END();
13577 
13578 
13579  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024120_2)
13580  {
13581  unsigned char key_str[128];
13582  unsigned char src_str[128];
13583  unsigned char dst_str[257];
13584  unsigned char iv_str[128];
13585  unsigned char add_str[128];
13586  unsigned char tag_str[128];
13587  unsigned char output[128];
13588  gcm_context ctx;
13589  unsigned int key_len;
13590  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
13591  int ret;
13592 
13593  memset(key_str, 0x00, 128);
13594  memset(src_str, 0x00, 128);
13595  memset(dst_str, 0x00, 257);
13596  memset(iv_str, 0x00, 128);
13597  memset(add_str, 0x00, 128);
13598  memset(tag_str, 0x00, 128);
13599  memset(output, 0x00, 128);
13600 
13601  key_len = unhexify( key_str, "7be3909170ea7a2ff76f9f28241d8cc48ddeafa8517c6f8c" );
13602  pt_len = unhexify( src_str, "" );
13603  iv_len = unhexify( iv_str, "8dee7e29350c60c5bcfec89da6617d2e" );
13604  add_len = unhexify( add_str, "f6e9e7a7f9716760eb43060d5c80236a0f118b0f750ebd5df01fd2dba95c556ecd2e54a3f337767321abf569c8137a8e48c5b44037ba62951e9f9f709e6e4540a36d769f3945d01a20a2ed1891c415a16d95cab7ddf9bcebf18842c830067509a2a5d49a9684324c433d53824d2f8fd326b149af17f40e5bf5e49185738fba60" );
13605  unhexify( tag_str, "942b52277e9dc0a30d737d00f5e597" );
13606 
13607  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13608  if( 0 == 0 )
13609  {
13610  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13611 
13612  if( strcmp( "FAIL", "" ) == 0 )
13613  {
13614  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13615  }
13616  else
13617  {
13618  hexify( dst_str, output, pt_len );
13619 
13620  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13621  }
13622  }
13623  }
13624  FCT_TEST_END();
13625 
13626 
13627  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024112_0)
13628  {
13629  unsigned char key_str[128];
13630  unsigned char src_str[128];
13631  unsigned char dst_str[257];
13632  unsigned char iv_str[128];
13633  unsigned char add_str[128];
13634  unsigned char tag_str[128];
13635  unsigned char output[128];
13636  gcm_context ctx;
13637  unsigned int key_len;
13638  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
13639  int ret;
13640 
13641  memset(key_str, 0x00, 128);
13642  memset(src_str, 0x00, 128);
13643  memset(dst_str, 0x00, 257);
13644  memset(iv_str, 0x00, 128);
13645  memset(add_str, 0x00, 128);
13646  memset(tag_str, 0x00, 128);
13647  memset(output, 0x00, 128);
13648 
13649  key_len = unhexify( key_str, "1fe413bafc4753e1511b580c830449bee56e0e5b9acb852c" );
13650  pt_len = unhexify( src_str, "" );
13651  iv_len = unhexify( iv_str, "e30829f64f3eda13bfb2ac572aceb3de" );
13652  add_len = unhexify( add_str, "6c772d08b4d7507e35804572fa697c646c77301954cc5c160941e49e230697ed8c23338b9f30c3ead69b1c1a2329ff025dcd3c0d0a9cc83fee4979448aa71ddb9d569bedc8c497a2a4ac3b60d087d7872f0a110bf90493ae7da03b0953734223156cd2d6c562e4a978a6dd5cdb229dd58dd4d0f50ac015f2f5e89dac4aa29a19" );
13653  unhexify( tag_str, "87737873b82586bb29b406946cae" );
13654 
13655  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13656  if( 0 == 0 )
13657  {
13658  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13659 
13660  if( strcmp( "FAIL", "" ) == 0 )
13661  {
13662  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13663  }
13664  else
13665  {
13666  hexify( dst_str, output, pt_len );
13667 
13668  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13669  }
13670  }
13671  }
13672  FCT_TEST_END();
13673 
13674 
13675  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024112_1)
13676  {
13677  unsigned char key_str[128];
13678  unsigned char src_str[128];
13679  unsigned char dst_str[257];
13680  unsigned char iv_str[128];
13681  unsigned char add_str[128];
13682  unsigned char tag_str[128];
13683  unsigned char output[128];
13684  gcm_context ctx;
13685  unsigned int key_len;
13686  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
13687  int ret;
13688 
13689  memset(key_str, 0x00, 128);
13690  memset(src_str, 0x00, 128);
13691  memset(dst_str, 0x00, 257);
13692  memset(iv_str, 0x00, 128);
13693  memset(add_str, 0x00, 128);
13694  memset(tag_str, 0x00, 128);
13695  memset(output, 0x00, 128);
13696 
13697  key_len = unhexify( key_str, "b4bc4378d423931f9b320bb57df584c641406c1daa7448ad" );
13698  pt_len = unhexify( src_str, "" );
13699  iv_len = unhexify( iv_str, "eca70e10c0358838a3f4a45c4b016ccd" );
13700  add_len = unhexify( add_str, "68d1c045c1604e3c3dd4f7c7543240aca8dbc5266dc18c5a8071e8b09e3700b7cf819044b2722d8db92021f42a0afb295d7b16ecf4e4704a50a527a2e72d7f53617c358e3b7be3d7fecda612ce6842fcfaa68f2d1b8a59d8b8391779f2fab99f820862c94029f444abe62367c5de0a4becc359660e4a5366f7d482bdc362b866" );
13701  unhexify( tag_str, "06f95ca69c222a8985887925b15e" );
13702 
13703  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13704  if( 0 == 0 )
13705  {
13706  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13707 
13708  if( strcmp( "FAIL", "" ) == 0 )
13709  {
13710  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13711  }
13712  else
13713  {
13714  hexify( dst_str, output, pt_len );
13715 
13716  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13717  }
13718  }
13719  }
13720  FCT_TEST_END();
13721 
13722 
13723  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024112_2)
13724  {
13725  unsigned char key_str[128];
13726  unsigned char src_str[128];
13727  unsigned char dst_str[257];
13728  unsigned char iv_str[128];
13729  unsigned char add_str[128];
13730  unsigned char tag_str[128];
13731  unsigned char output[128];
13732  gcm_context ctx;
13733  unsigned int key_len;
13734  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
13735  int ret;
13736 
13737  memset(key_str, 0x00, 128);
13738  memset(src_str, 0x00, 128);
13739  memset(dst_str, 0x00, 257);
13740  memset(iv_str, 0x00, 128);
13741  memset(add_str, 0x00, 128);
13742  memset(tag_str, 0x00, 128);
13743  memset(output, 0x00, 128);
13744 
13745  key_len = unhexify( key_str, "1cd4414ffd24e830e2dc49727efa592e430a6a75391cf111" );
13746  pt_len = unhexify( src_str, "" );
13747  iv_len = unhexify( iv_str, "a08e32ad7d63f975de314ad2c0fa13fc" );
13748  add_len = unhexify( add_str, "20a271f1f4c6bea8f1584ab39a7179ec448650e2ff67a7338d1bc9fab7f73b2ce5222cd07ded947d135d9d0670dc368f0a4b50ece85cbf641877f9fe0ac6a7e6afb32fdb1b3cd35360bb80cfffc34cfb94dbcbee9ca5be98a0ca846394a135860fba57c6f0125dcb9fb8b61be681ada31a997638ee172525c03dd13171534a91" );
13749  unhexify( tag_str, "c68842cafc50070799f7c8acd62a" );
13750 
13751  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13752  if( 0 == 0 )
13753  {
13754  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13755 
13756  if( strcmp( "FAIL", "" ) == 0 )
13757  {
13758  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13759  }
13760  else
13761  {
13762  hexify( dst_str, output, pt_len );
13763 
13764  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13765  }
13766  }
13767  }
13768  FCT_TEST_END();
13769 
13770 
13771  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024104_0)
13772  {
13773  unsigned char key_str[128];
13774  unsigned char src_str[128];
13775  unsigned char dst_str[257];
13776  unsigned char iv_str[128];
13777  unsigned char add_str[128];
13778  unsigned char tag_str[128];
13779  unsigned char output[128];
13780  gcm_context ctx;
13781  unsigned int key_len;
13782  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
13783  int ret;
13784 
13785  memset(key_str, 0x00, 128);
13786  memset(src_str, 0x00, 128);
13787  memset(dst_str, 0x00, 257);
13788  memset(iv_str, 0x00, 128);
13789  memset(add_str, 0x00, 128);
13790  memset(tag_str, 0x00, 128);
13791  memset(output, 0x00, 128);
13792 
13793  key_len = unhexify( key_str, "9e0ef9ed5e6f00a721a9893e1f0d9079c5aa667a4cdd2a52" );
13794  pt_len = unhexify( src_str, "" );
13795  iv_len = unhexify( iv_str, "5f015fd556e87ff0d0df586fb452306d" );
13796  add_len = unhexify( add_str, "b82986135e49e03f6f8f3ce4048ded2e63ee0c31ddc84929e022ee8561159179b3bb4403ebdafdf6beae51ac5bf4abed4dbc251433417ece3228b260eca5134e5390cba49a0b6fcbbbabb085378374e4e671d9ba265298e9864bfce256884247c36f9bddceb79b6a3e700cb3dd40088ba7bb6ab6aa11b6be261a7e5348f4a7d1" );
13797  unhexify( tag_str, "ec9a79a88a164e1a6253d8312e" );
13798 
13799  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13800  if( 0 == 0 )
13801  {
13802  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13803 
13804  if( strcmp( "FAIL", "FAIL" ) == 0 )
13805  {
13806  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13807  }
13808  else
13809  {
13810  hexify( dst_str, output, pt_len );
13811 
13812  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
13813  }
13814  }
13815  }
13816  FCT_TEST_END();
13817 
13818 
13819  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024104_1)
13820  {
13821  unsigned char key_str[128];
13822  unsigned char src_str[128];
13823  unsigned char dst_str[257];
13824  unsigned char iv_str[128];
13825  unsigned char add_str[128];
13826  unsigned char tag_str[128];
13827  unsigned char output[128];
13828  gcm_context ctx;
13829  unsigned int key_len;
13830  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
13831  int ret;
13832 
13833  memset(key_str, 0x00, 128);
13834  memset(src_str, 0x00, 128);
13835  memset(dst_str, 0x00, 257);
13836  memset(iv_str, 0x00, 128);
13837  memset(add_str, 0x00, 128);
13838  memset(tag_str, 0x00, 128);
13839  memset(output, 0x00, 128);
13840 
13841  key_len = unhexify( key_str, "9bc8f15d98e089d60d4db00808700053f78b33c31652c3e4" );
13842  pt_len = unhexify( src_str, "" );
13843  iv_len = unhexify( iv_str, "5cc0ff9bb7d5b9b2aa06f6ecf669d5bb" );
13844  add_len = unhexify( add_str, "24ac95a6ed2f78853f9ab20f53de47e7f662f72aea454141e2131aace7ed2daeb395bbccdbf004e23ce04ad85909f30151b6526c1ce7934726f99997bbab27055b379e5e43b80ad546e2d1655d1adad4cbe51282643bb4df086deb1b48c1bd3ac3b53c4a406be2687174028ecf7e7976e5c7a11c9a3827813ade32baef9f15ec" );
13845  unhexify( tag_str, "9779b7c3ece6c23d5813e243ec" );
13846 
13847  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13848  if( 0 == 0 )
13849  {
13850  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13851 
13852  if( strcmp( "FAIL", "" ) == 0 )
13853  {
13854  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13855  }
13856  else
13857  {
13858  hexify( dst_str, output, pt_len );
13859 
13860  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
13861  }
13862  }
13863  }
13864  FCT_TEST_END();
13865 
13866 
13867  FCT_TEST_BGN(gcm_nist_validation_aes_19212801024104_2)
13868  {
13869  unsigned char key_str[128];
13870  unsigned char src_str[128];
13871  unsigned char dst_str[257];
13872  unsigned char iv_str[128];
13873  unsigned char add_str[128];
13874  unsigned char tag_str[128];
13875  unsigned char output[128];
13876  gcm_context ctx;
13877  unsigned int key_len;
13878  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
13879  int ret;
13880 
13881  memset(key_str, 0x00, 128);
13882  memset(src_str, 0x00, 128);
13883  memset(dst_str, 0x00, 257);
13884  memset(iv_str, 0x00, 128);
13885  memset(add_str, 0x00, 128);
13886  memset(tag_str, 0x00, 128);
13887  memset(output, 0x00, 128);
13888 
13889  key_len = unhexify( key_str, "19afc43a4481f796d77561f80b5b2e1514c96c5d1d86e64c" );
13890  pt_len = unhexify( src_str, "" );
13891  iv_len = unhexify( iv_str, "d4c06595fefd4a81bbbd4b40c2e1989d" );
13892  add_len = unhexify( add_str, "98fcca51352998d0126b5539e3fb9a238ac31c05954fc206d381909aee70983b6ab99d3f3efe8530a1c3cfe3b62756321b1d0771a5940055eba1e71fa64f29291aa5e5b0af0fcc8e6f5a02688d9e93417225eded791a35217822ffb346d3fa2809b65abe729448316be30cf661137d3c0e49846cb0df598d90eda545afb64a5e" );
13893  unhexify( tag_str, "ca82448429106009094c21d70b" );
13894 
13895  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13896  if( 0 == 0 )
13897  {
13898  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13899 
13900  if( strcmp( "FAIL", "FAIL" ) == 0 )
13901  {
13902  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13903  }
13904  else
13905  {
13906  hexify( dst_str, output, pt_len );
13907 
13908  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
13909  }
13910  }
13911  }
13912  FCT_TEST_END();
13913 
13914 
13915  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102496_0)
13916  {
13917  unsigned char key_str[128];
13918  unsigned char src_str[128];
13919  unsigned char dst_str[257];
13920  unsigned char iv_str[128];
13921  unsigned char add_str[128];
13922  unsigned char tag_str[128];
13923  unsigned char output[128];
13924  gcm_context ctx;
13925  unsigned int key_len;
13926  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
13927  int ret;
13928 
13929  memset(key_str, 0x00, 128);
13930  memset(src_str, 0x00, 128);
13931  memset(dst_str, 0x00, 257);
13932  memset(iv_str, 0x00, 128);
13933  memset(add_str, 0x00, 128);
13934  memset(tag_str, 0x00, 128);
13935  memset(output, 0x00, 128);
13936 
13937  key_len = unhexify( key_str, "b4fc31dcfef6203fdb296cc928c13b7df56bfe6f32583057" );
13938  pt_len = unhexify( src_str, "" );
13939  iv_len = unhexify( iv_str, "6308a78dc8f3c90442dc52196649c38e" );
13940  add_len = unhexify( add_str, "2567d80c253b080c0158102558551445d8ce4d5ddee2014a2be5cbad62e1717a0fd4d2059447c3151192951eb11a4a7b19a952f6ba261c87f10f4c9032028de3cc5a2a573a4e993a690fc8954daa3ec92743e7343e75b646c4fa9cbc3fceb4f5d59bb439c23754c4d9666fbc16c90c0cac91679b6ad1bfe5dcf6bd1a8a67c6b5" );
13941  unhexify( tag_str, "9d1603799e2485a03e7b05a0" );
13942 
13943  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13944  if( 0 == 0 )
13945  {
13946  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13947 
13948  if( strcmp( "FAIL", "FAIL" ) == 0 )
13949  {
13950  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13951  }
13952  else
13953  {
13954  hexify( dst_str, output, pt_len );
13955 
13956  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
13957  }
13958  }
13959  }
13960  FCT_TEST_END();
13961 
13962 
13963  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102496_1)
13964  {
13965  unsigned char key_str[128];
13966  unsigned char src_str[128];
13967  unsigned char dst_str[257];
13968  unsigned char iv_str[128];
13969  unsigned char add_str[128];
13970  unsigned char tag_str[128];
13971  unsigned char output[128];
13972  gcm_context ctx;
13973  unsigned int key_len;
13974  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
13975  int ret;
13976 
13977  memset(key_str, 0x00, 128);
13978  memset(src_str, 0x00, 128);
13979  memset(dst_str, 0x00, 257);
13980  memset(iv_str, 0x00, 128);
13981  memset(add_str, 0x00, 128);
13982  memset(tag_str, 0x00, 128);
13983  memset(output, 0x00, 128);
13984 
13985  key_len = unhexify( key_str, "1c2d9412486c381440213e1588b6bb58b0da53300b9d3089" );
13986  pt_len = unhexify( src_str, "" );
13987  iv_len = unhexify( iv_str, "727ed8846daab874d5a9918b47d016f4" );
13988  add_len = unhexify( add_str, "656430f0c1423018b5e2efbb1e32a5385c1a9a1779c4dbd585dea91edc39ea8752ebfc2d8064251a8a5ae71e1845f24a7e42c6371c2ecb31e2229d5f4923bffc21d4804575a84836f3cf90ec6047bb360b558a41a975ece111b5284dfa2441705a6df54fc66ca6cc1af9163ecc46902fac337d5f67f563fde8e8e7e64b8588b7" );
13989  unhexify( tag_str, "05ee6ce13711535864674a5b" );
13990 
13991  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
13992  if( 0 == 0 )
13993  {
13994  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
13995 
13996  if( strcmp( "FAIL", "" ) == 0 )
13997  {
13998  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
13999  }
14000  else
14001  {
14002  hexify( dst_str, output, pt_len );
14003 
14004  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
14005  }
14006  }
14007  }
14008  FCT_TEST_END();
14009 
14010 
14011  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102496_2)
14012  {
14013  unsigned char key_str[128];
14014  unsigned char src_str[128];
14015  unsigned char dst_str[257];
14016  unsigned char iv_str[128];
14017  unsigned char add_str[128];
14018  unsigned char tag_str[128];
14019  unsigned char output[128];
14020  gcm_context ctx;
14021  unsigned int key_len;
14022  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
14023  int ret;
14024 
14025  memset(key_str, 0x00, 128);
14026  memset(src_str, 0x00, 128);
14027  memset(dst_str, 0x00, 257);
14028  memset(iv_str, 0x00, 128);
14029  memset(add_str, 0x00, 128);
14030  memset(tag_str, 0x00, 128);
14031  memset(output, 0x00, 128);
14032 
14033  key_len = unhexify( key_str, "abf7a97569427225a4bd5143c716a22e62f84c145bb51511" );
14034  pt_len = unhexify( src_str, "" );
14035  iv_len = unhexify( iv_str, "e255088cdfe8ae5c9fea86d74d2f1b7d" );
14036  add_len = unhexify( add_str, "b850993300f54d078f83ceb9aef7345bbf758f92365b6625c210f61dad4f2a2319f51d883a383a706392d3dfca1706eba585a6fac8bd4294c0bb2cb3f6b454d5c97819e8e5c926754840261b07ec4ef1f87cf281d75c187839689944230306e1903047915e086043990745864819ad713d34a244aa4e9d755fdb137105d7eed8" );
14037  unhexify( tag_str, "0c9c17388d0610f99d0a093f" );
14038 
14039  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14040  if( 0 == 0 )
14041  {
14042  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14043 
14044  if( strcmp( "FAIL", "" ) == 0 )
14045  {
14046  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14047  }
14048  else
14049  {
14050  hexify( dst_str, output, pt_len );
14051 
14052  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
14053  }
14054  }
14055  }
14056  FCT_TEST_END();
14057 
14058 
14059  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102464_0)
14060  {
14061  unsigned char key_str[128];
14062  unsigned char src_str[128];
14063  unsigned char dst_str[257];
14064  unsigned char iv_str[128];
14065  unsigned char add_str[128];
14066  unsigned char tag_str[128];
14067  unsigned char output[128];
14068  gcm_context ctx;
14069  unsigned int key_len;
14070  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
14071  int ret;
14072 
14073  memset(key_str, 0x00, 128);
14074  memset(src_str, 0x00, 128);
14075  memset(dst_str, 0x00, 257);
14076  memset(iv_str, 0x00, 128);
14077  memset(add_str, 0x00, 128);
14078  memset(tag_str, 0x00, 128);
14079  memset(output, 0x00, 128);
14080 
14081  key_len = unhexify( key_str, "45a6df655e88bc880acff41520aafd0cc8aa8aeb8952fd06" );
14082  pt_len = unhexify( src_str, "" );
14083  iv_len = unhexify( iv_str, "1125e1de94970c9e7be70e58e7626ef4" );
14084  add_len = unhexify( add_str, "fe9838a445b8edef19b3e9f33c8c0c265b3a12c97b8ec57ceb94f65ae5227177de38f1e338dccb2b24e5bd0f0eb8127f83eba0f1ddfa55198789df0cdd1d977fcb985ad9c7d51b96e749d2cf3cc7a1ec4dfcbc641a1a022d55def328e081af890a7e699f2dbafdf506389e045aa1219239d5868ba675a3925602b6fb6f6e6d37" );
14085  unhexify( tag_str, "1c3bd1e0d4918e36" );
14086 
14087  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14088  if( 0 == 0 )
14089  {
14090  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14091 
14092  if( strcmp( "FAIL", "FAIL" ) == 0 )
14093  {
14094  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14095  }
14096  else
14097  {
14098  hexify( dst_str, output, pt_len );
14099 
14100  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14101  }
14102  }
14103  }
14104  FCT_TEST_END();
14105 
14106 
14107  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102464_1)
14108  {
14109  unsigned char key_str[128];
14110  unsigned char src_str[128];
14111  unsigned char dst_str[257];
14112  unsigned char iv_str[128];
14113  unsigned char add_str[128];
14114  unsigned char tag_str[128];
14115  unsigned char output[128];
14116  gcm_context ctx;
14117  unsigned int key_len;
14118  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
14119  int ret;
14120 
14121  memset(key_str, 0x00, 128);
14122  memset(src_str, 0x00, 128);
14123  memset(dst_str, 0x00, 257);
14124  memset(iv_str, 0x00, 128);
14125  memset(add_str, 0x00, 128);
14126  memset(tag_str, 0x00, 128);
14127  memset(output, 0x00, 128);
14128 
14129  key_len = unhexify( key_str, "279f4f2ab4b70778fdb9ca7800cd20e323601d7aa2c75366" );
14130  pt_len = unhexify( src_str, "" );
14131  iv_len = unhexify( iv_str, "0f7b402560735cf03d5da58de5b6c685" );
14132  add_len = unhexify( add_str, "7dd9a8c848bbcf5127161c8a419a436a0dad559f7c1613cdf41594e177016acb1ccf44be852185c42e7120902a42efe83855995ab52cf5c190d499fcfd698c671fd72949dc3ea7ddb874e586a3aa455a021cec7b5f8608462ca66f926aba76e60a5846d4eb204155cd3c1328da51ba35c3007b8bb394f34e3a8b81ddd2ea1115" );
14133  unhexify( tag_str, "dab612351f75e2cb" );
14134 
14135  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14136  if( 0 == 0 )
14137  {
14138  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14139 
14140  if( strcmp( "FAIL", "" ) == 0 )
14141  {
14142  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14143  }
14144  else
14145  {
14146  hexify( dst_str, output, pt_len );
14147 
14148  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
14149  }
14150  }
14151  }
14152  FCT_TEST_END();
14153 
14154 
14155  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102464_2)
14156  {
14157  unsigned char key_str[128];
14158  unsigned char src_str[128];
14159  unsigned char dst_str[257];
14160  unsigned char iv_str[128];
14161  unsigned char add_str[128];
14162  unsigned char tag_str[128];
14163  unsigned char output[128];
14164  gcm_context ctx;
14165  unsigned int key_len;
14166  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
14167  int ret;
14168 
14169  memset(key_str, 0x00, 128);
14170  memset(src_str, 0x00, 128);
14171  memset(dst_str, 0x00, 257);
14172  memset(iv_str, 0x00, 128);
14173  memset(add_str, 0x00, 128);
14174  memset(tag_str, 0x00, 128);
14175  memset(output, 0x00, 128);
14176 
14177  key_len = unhexify( key_str, "6716ab937755684af7403e6fba5452c1b11568a9047bb50f" );
14178  pt_len = unhexify( src_str, "" );
14179  iv_len = unhexify( iv_str, "2fd5a446dd564619ef75b6e00905ffe0" );
14180  add_len = unhexify( add_str, "20d261d3192996c21da69e979c26f5f937e6ea4cb7b05c6ef556ce4d86ca0fe85ec2425d274c43b5212fe9d27bb48b04e887461a9f45f524059b87eaea2e287a8d4537f338b0212012a9d4b6610e8c97dd554e0b3c3133e05c14d0ddab3524c93fd527e223b1996b4cff0a4a7438f1d54890bf573cd803941b69e5fc6212c5d2" );
14181  unhexify( tag_str, "f1d743b7e1b73af5" );
14182 
14183  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14184  if( 0 == 0 )
14185  {
14186  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14187 
14188  if( strcmp( "FAIL", "FAIL" ) == 0 )
14189  {
14190  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14191  }
14192  else
14193  {
14194  hexify( dst_str, output, pt_len );
14195 
14196  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14197  }
14198  }
14199  }
14200  FCT_TEST_END();
14201 
14202 
14203  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102432_0)
14204  {
14205  unsigned char key_str[128];
14206  unsigned char src_str[128];
14207  unsigned char dst_str[257];
14208  unsigned char iv_str[128];
14209  unsigned char add_str[128];
14210  unsigned char tag_str[128];
14211  unsigned char output[128];
14212  gcm_context ctx;
14213  unsigned int key_len;
14214  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
14215  int ret;
14216 
14217  memset(key_str, 0x00, 128);
14218  memset(src_str, 0x00, 128);
14219  memset(dst_str, 0x00, 257);
14220  memset(iv_str, 0x00, 128);
14221  memset(add_str, 0x00, 128);
14222  memset(tag_str, 0x00, 128);
14223  memset(output, 0x00, 128);
14224 
14225  key_len = unhexify( key_str, "7dc94b5bbd6315ad8d2b67f0c683d10cf456f822a3ebb024" );
14226  pt_len = unhexify( src_str, "" );
14227  iv_len = unhexify( iv_str, "6f3eedeb57dcf12bfb3cd80849893c90" );
14228  add_len = unhexify( add_str, "ee1ff367f4b23c156e3dccff84ae4bf2b8ecec1fb5ffd25ccaa93b6c6834389bd79655bd4bac75238eb0f65d3603ecc57c8774798309e85b6677e78ed2077b712cf28795d0dc8fee994f97373a82338ef67c62378136a79a990ecbcd6367445e805efa98f9168826e57cb8dd7e7b1d5c89ad98358646fa56dd2a71c40e0275a1" );
14229  unhexify( tag_str, "4dc74971" );
14230 
14231  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14232  if( 0 == 0 )
14233  {
14234  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14235 
14236  if( strcmp( "FAIL", "" ) == 0 )
14237  {
14238  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14239  }
14240  else
14241  {
14242  hexify( dst_str, output, pt_len );
14243 
14244  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
14245  }
14246  }
14247  }
14248  FCT_TEST_END();
14249 
14250 
14251  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102432_1)
14252  {
14253  unsigned char key_str[128];
14254  unsigned char src_str[128];
14255  unsigned char dst_str[257];
14256  unsigned char iv_str[128];
14257  unsigned char add_str[128];
14258  unsigned char tag_str[128];
14259  unsigned char output[128];
14260  gcm_context ctx;
14261  unsigned int key_len;
14262  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
14263  int ret;
14264 
14265  memset(key_str, 0x00, 128);
14266  memset(src_str, 0x00, 128);
14267  memset(dst_str, 0x00, 257);
14268  memset(iv_str, 0x00, 128);
14269  memset(add_str, 0x00, 128);
14270  memset(tag_str, 0x00, 128);
14271  memset(output, 0x00, 128);
14272 
14273  key_len = unhexify( key_str, "3bbe223e253bf272599e28af6861013ecd0c88710947ed41" );
14274  pt_len = unhexify( src_str, "" );
14275  iv_len = unhexify( iv_str, "4fbf09ffaffb600f0de38fb12315cab5" );
14276  add_len = unhexify( add_str, "5388146f6479f7b3b280f45655a95b847ee27c734fb2fd91f6c009b1ab1810c772c7435d3221069f9490d251b76e740147906ac1db1c209c175b21aa10881c44fb307d4d2900aa3b1d56fb0edb9f2a58505653a17fee350e12755b9656bc65c78c1593d5cb7178e29f82209caf53e60fddf725f6957cc9718bf410c4a0229ed4" );
14277  unhexify( tag_str, "fb845ab7" );
14278 
14279  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14280  if( 0 == 0 )
14281  {
14282  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14283 
14284  if( strcmp( "FAIL", "FAIL" ) == 0 )
14285  {
14286  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14287  }
14288  else
14289  {
14290  hexify( dst_str, output, pt_len );
14291 
14292  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14293  }
14294  }
14295  }
14296  FCT_TEST_END();
14297 
14298 
14299  FCT_TEST_BGN(gcm_nist_validation_aes_1921280102432_2)
14300  {
14301  unsigned char key_str[128];
14302  unsigned char src_str[128];
14303  unsigned char dst_str[257];
14304  unsigned char iv_str[128];
14305  unsigned char add_str[128];
14306  unsigned char tag_str[128];
14307  unsigned char output[128];
14308  gcm_context ctx;
14309  unsigned int key_len;
14310  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
14311  int ret;
14312 
14313  memset(key_str, 0x00, 128);
14314  memset(src_str, 0x00, 128);
14315  memset(dst_str, 0x00, 257);
14316  memset(iv_str, 0x00, 128);
14317  memset(add_str, 0x00, 128);
14318  memset(tag_str, 0x00, 128);
14319  memset(output, 0x00, 128);
14320 
14321  key_len = unhexify( key_str, "461877813acfe6e9979eab729b52e3d192b3236758bb6563" );
14322  pt_len = unhexify( src_str, "" );
14323  iv_len = unhexify( iv_str, "6985cf77b75a47a3978dd6412d59200b" );
14324  add_len = unhexify( add_str, "385551854a89ab37063ba0ed911501b3d632153c5c2992e154c0a334bc36620476f11495437b842409e0954f7352cbf288d158bdbbaf72621ea2ce75b708bc276f796c5aa7fd0071e522c5f175a9e7787deef79f6362101aa3607b4588f2e1df7127f617c6073593a1c792b959e201e4a7a43ea8b1c3af026376439ef629266c" );
14325  unhexify( tag_str, "c840d994" );
14326 
14327  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14328  if( 0 == 0 )
14329  {
14330  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14331 
14332  if( strcmp( "FAIL", "FAIL" ) == 0 )
14333  {
14334  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14335  }
14336  else
14337  {
14338  hexify( dst_str, output, pt_len );
14339 
14340  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14341  }
14342  }
14343  }
14344  FCT_TEST_END();
14345 
14346 
14347  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240128_0)
14348  {
14349  unsigned char key_str[128];
14350  unsigned char src_str[128];
14351  unsigned char dst_str[257];
14352  unsigned char iv_str[128];
14353  unsigned char add_str[128];
14354  unsigned char tag_str[128];
14355  unsigned char output[128];
14356  gcm_context ctx;
14357  unsigned int key_len;
14358  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
14359  int ret;
14360 
14361  memset(key_str, 0x00, 128);
14362  memset(src_str, 0x00, 128);
14363  memset(dst_str, 0x00, 257);
14364  memset(iv_str, 0x00, 128);
14365  memset(add_str, 0x00, 128);
14366  memset(tag_str, 0x00, 128);
14367  memset(output, 0x00, 128);
14368 
14369  key_len = unhexify( key_str, "09770f9114120a2c1c3cc416fe0eb8699e07141158a5bdff" );
14370  pt_len = unhexify( src_str, "875e2e5b5c02e0a33e71b678aa29c15ce18ec259cf4b41874893ed3112daa56ff2a7475681b8b3d9028ef184d30658e881c908f3588f69899962074db4ddfc0597f8debb66c8388a1bccf0ffe2cf9f078dc1c93f8191f920754442ad4a325985c62de1a57a25de4e9ed5c2fd0f2c8af33f3b140bac12bf60fdb33e0ec557955b" );
14371  iv_len = unhexify( iv_str, "cff291d2364fc06a3a89e867b0e67e56" );
14372  add_len = unhexify( add_str, "" );
14373  unhexify( tag_str, "81f1eb568d0af29680518df7378ba3e8" );
14374 
14375  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14376  if( 0 == 0 )
14377  {
14378  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14379 
14380  if( strcmp( "FAIL", "FAIL" ) == 0 )
14381  {
14382  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14383  }
14384  else
14385  {
14386  hexify( dst_str, output, pt_len );
14387 
14388  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14389  }
14390  }
14391  }
14392  FCT_TEST_END();
14393 
14394 
14395  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240128_1)
14396  {
14397  unsigned char key_str[128];
14398  unsigned char src_str[128];
14399  unsigned char dst_str[257];
14400  unsigned char iv_str[128];
14401  unsigned char add_str[128];
14402  unsigned char tag_str[128];
14403  unsigned char output[128];
14404  gcm_context ctx;
14405  unsigned int key_len;
14406  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
14407  int ret;
14408 
14409  memset(key_str, 0x00, 128);
14410  memset(src_str, 0x00, 128);
14411  memset(dst_str, 0x00, 257);
14412  memset(iv_str, 0x00, 128);
14413  memset(add_str, 0x00, 128);
14414  memset(tag_str, 0x00, 128);
14415  memset(output, 0x00, 128);
14416 
14417  key_len = unhexify( key_str, "4fbf1c785c087ad06b43d4163cf9b9396deffd3712856379" );
14418  pt_len = unhexify( src_str, "96a690e5319c94d94923988025307e543f16fd970aec24524cf9808dc62b093359287251503f4231bf52cd1a16a80bfa82d8f585d96855dc1932f4919a92da2618d6448fc18a234f9acb386ab4ab4a9e38ea341e7c54faceff38c162d74e7fabbca13aadb71e9c8ae6072e7bef4073cf08aa7faaa6d639f98d15bad4ed183ced" );
14419  iv_len = unhexify( iv_str, "1c8f41424acaf009996ceaa815b24ad4" );
14420  add_len = unhexify( add_str, "" );
14421  unhexify( tag_str, "9f3c0349c5a4a740a82d6d63bf00fb17" );
14422 
14423  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14424  if( 0 == 0 )
14425  {
14426  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14427 
14428  if( strcmp( "FAIL", "6100b091e52366fb422251d9b68974b6c666a62a8bb77a1ffd7c7d1ae586a6ee763b84dc11aace02a25af91d194b70b3265ec46872fded54275b7ddb26ee1f20c857328f46a694fb1dce68bcaecbd587ece5b505d658d57d50333e30b639eea1f6537b37c175f62497c6c84e3cfddae214285d2d68d90dd5cd8ce2273d25c8ca" ) == 0 )
14429  {
14430  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14431  }
14432  else
14433  {
14434  hexify( dst_str, output, pt_len );
14435 
14436  fct_chk( strcmp( (char *) dst_str, "6100b091e52366fb422251d9b68974b6c666a62a8bb77a1ffd7c7d1ae586a6ee763b84dc11aace02a25af91d194b70b3265ec46872fded54275b7ddb26ee1f20c857328f46a694fb1dce68bcaecbd587ece5b505d658d57d50333e30b639eea1f6537b37c175f62497c6c84e3cfddae214285d2d68d90dd5cd8ce2273d25c8ca" ) == 0 );
14437  }
14438  }
14439  }
14440  FCT_TEST_END();
14441 
14442 
14443  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240128_2)
14444  {
14445  unsigned char key_str[128];
14446  unsigned char src_str[128];
14447  unsigned char dst_str[257];
14448  unsigned char iv_str[128];
14449  unsigned char add_str[128];
14450  unsigned char tag_str[128];
14451  unsigned char output[128];
14452  gcm_context ctx;
14453  unsigned int key_len;
14454  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
14455  int ret;
14456 
14457  memset(key_str, 0x00, 128);
14458  memset(src_str, 0x00, 128);
14459  memset(dst_str, 0x00, 257);
14460  memset(iv_str, 0x00, 128);
14461  memset(add_str, 0x00, 128);
14462  memset(tag_str, 0x00, 128);
14463  memset(output, 0x00, 128);
14464 
14465  key_len = unhexify( key_str, "3e0ce4fb4fe4bb2fdf97b23084ff5671b9b899624184acef" );
14466  pt_len = unhexify( src_str, "df89974b1534f0ba262bbea5efe39d8b72820cc8a720cc99520fedbf667515c3f6d8c3e25c72c48c1cff042171df58421741aacb2a49f23167257be7d7004d56b14901b2075eaca85946e9fbf1bbf4ae98227efc62bf255a25dd0402d37c67ba553531c699dd89ff797e7a5b5b9a9aa51e73ca2dacfda0f814152aa8ed8c79f9" );
14467  iv_len = unhexify( iv_str, "a950ab0dd84115e3829ab0ad3bbb1193" );
14468  add_len = unhexify( add_str, "" );
14469  unhexify( tag_str, "25cfde73e7a29115828dfe1617f8b53e" );
14470 
14471  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14472  if( 0 == 0 )
14473  {
14474  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14475 
14476  if( strcmp( "FAIL", "847b54e176ccc83081cb966efc4b4a3bf7809ce0b4885009f620f61fafcaa78feee91a835ae6c1a942571811108b1e81b4c4ddac46aaff599c14988c9a1fb9f387ab7f1357b581568b7b34e167ac2c8c2b2b8a4df3fd7ad8947a363c1c0cb782ec54b1901e928821cf319669dd77eb37b15c67f13ad787ff74312812731ca3e6" ) == 0 )
14477  {
14478  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14479  }
14480  else
14481  {
14482  hexify( dst_str, output, pt_len );
14483 
14484  fct_chk( strcmp( (char *) dst_str, "847b54e176ccc83081cb966efc4b4a3bf7809ce0b4885009f620f61fafcaa78feee91a835ae6c1a942571811108b1e81b4c4ddac46aaff599c14988c9a1fb9f387ab7f1357b581568b7b34e167ac2c8c2b2b8a4df3fd7ad8947a363c1c0cb782ec54b1901e928821cf319669dd77eb37b15c67f13ad787ff74312812731ca3e6" ) == 0 );
14485  }
14486  }
14487  }
14488  FCT_TEST_END();
14489 
14490 
14491  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240120_0)
14492  {
14493  unsigned char key_str[128];
14494  unsigned char src_str[128];
14495  unsigned char dst_str[257];
14496  unsigned char iv_str[128];
14497  unsigned char add_str[128];
14498  unsigned char tag_str[128];
14499  unsigned char output[128];
14500  gcm_context ctx;
14501  unsigned int key_len;
14502  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
14503  int ret;
14504 
14505  memset(key_str, 0x00, 128);
14506  memset(src_str, 0x00, 128);
14507  memset(dst_str, 0x00, 257);
14508  memset(iv_str, 0x00, 128);
14509  memset(add_str, 0x00, 128);
14510  memset(tag_str, 0x00, 128);
14511  memset(output, 0x00, 128);
14512 
14513  key_len = unhexify( key_str, "6be3c66b20e5e66ababbfba1b38e5a716eafce23a1767b69" );
14514  pt_len = unhexify( src_str, "de1cd978354a499415176f260021abe0a8c5bc34d166f53d20e02e413e1377ce4ef5d7f58337c62251a3b4ddea0dea23c40e5de037fd5dd8a558eb53bffa4e8ce94899afa8284afab503c1a485999a154d23777f9d8a031b7ad5c6d23d6abbe3b775c77876ad50f6bed14ac0b2b88fb19c438e4b7eb03f7d4d3fcca90dd01260" );
14515  iv_len = unhexify( iv_str, "3a2acf69bba19f5d1d1947af2cfda781" );
14516  add_len = unhexify( add_str, "" );
14517  unhexify( tag_str, "f826d212f7c1212fb8a8bf23996826" );
14518 
14519  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14520  if( 0 == 0 )
14521  {
14522  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14523 
14524  if( strcmp( "FAIL", "fd1f7b56e5664cf4c91e58f7c50f6c5e98e42ca2e4adcc00348cee6f662b382ad4022da54a47d8faeb9b76a24dfc4f493c27fc0bc421a4648fad7b14b0df95d8752013feb033b1fd971daa2c9a5df898bece6a3b8fa078dd130071df20a68cd0f394be25dcbb3e85bdfa0df4797fa6f01f5f0da7a6e86320207ddb5b3be53ae0" ) == 0 )
14525  {
14526  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14527  }
14528  else
14529  {
14530  hexify( dst_str, output, pt_len );
14531 
14532  fct_chk( strcmp( (char *) dst_str, "fd1f7b56e5664cf4c91e58f7c50f6c5e98e42ca2e4adcc00348cee6f662b382ad4022da54a47d8faeb9b76a24dfc4f493c27fc0bc421a4648fad7b14b0df95d8752013feb033b1fd971daa2c9a5df898bece6a3b8fa078dd130071df20a68cd0f394be25dcbb3e85bdfa0df4797fa6f01f5f0da7a6e86320207ddb5b3be53ae0" ) == 0 );
14533  }
14534  }
14535  }
14536  FCT_TEST_END();
14537 
14538 
14539  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240120_1)
14540  {
14541  unsigned char key_str[128];
14542  unsigned char src_str[128];
14543  unsigned char dst_str[257];
14544  unsigned char iv_str[128];
14545  unsigned char add_str[128];
14546  unsigned char tag_str[128];
14547  unsigned char output[128];
14548  gcm_context ctx;
14549  unsigned int key_len;
14550  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
14551  int ret;
14552 
14553  memset(key_str, 0x00, 128);
14554  memset(src_str, 0x00, 128);
14555  memset(dst_str, 0x00, 257);
14556  memset(iv_str, 0x00, 128);
14557  memset(add_str, 0x00, 128);
14558  memset(tag_str, 0x00, 128);
14559  memset(output, 0x00, 128);
14560 
14561  key_len = unhexify( key_str, "d16abb9f5b38d7f5abba9dc36995ce6ce928ed822a07b7c4" );
14562  pt_len = unhexify( src_str, "e72f29b1fc1dbfc2d93a0f3b79ea4b9806ce9b2c4d490ac5c0c3c793df9dc7df5471e834b84d18afa5a7516f9a6a813a9b65ae2f083a854730547e28a1f60fe97d8dba1d2d433e11847b9bffd8873ec634e64365530c905dd6f274e45c9795ac127a6f356f63cc6c116c5dd8c628e7e17e1fadc58f8452bf21f53c4133198118" );
14563  iv_len = unhexify( iv_str, "3cd95429c6de1d327b9eb3c45424a87c" );
14564  add_len = unhexify( add_str, "" );
14565  unhexify( tag_str, "13521236f190f78e75c0897c5fb237" );
14566 
14567  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14568  if( 0 == 0 )
14569  {
14570  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14571 
14572  if( strcmp( "FAIL", "cd8bb97c28df092b6783ef653fd26f2bdc27c442bab0a4c7bee2789f389dcd1b280c0231672721bfbbc939a0449557678ec61ba0afb2e5817e6f7d94387f84ecafbfa1216d65e7f5025f47b0d2905cff7c99adf8306a3d9850c5908be05f87cb1d36a4837dba428aac97d7fbc18e3778f8d81a319259504c87fc94bd0766ed93" ) == 0 )
14573  {
14574  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14575  }
14576  else
14577  {
14578  hexify( dst_str, output, pt_len );
14579 
14580  fct_chk( strcmp( (char *) dst_str, "cd8bb97c28df092b6783ef653fd26f2bdc27c442bab0a4c7bee2789f389dcd1b280c0231672721bfbbc939a0449557678ec61ba0afb2e5817e6f7d94387f84ecafbfa1216d65e7f5025f47b0d2905cff7c99adf8306a3d9850c5908be05f87cb1d36a4837dba428aac97d7fbc18e3778f8d81a319259504c87fc94bd0766ed93" ) == 0 );
14581  }
14582  }
14583  }
14584  FCT_TEST_END();
14585 
14586 
14587  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240120_2)
14588  {
14589  unsigned char key_str[128];
14590  unsigned char src_str[128];
14591  unsigned char dst_str[257];
14592  unsigned char iv_str[128];
14593  unsigned char add_str[128];
14594  unsigned char tag_str[128];
14595  unsigned char output[128];
14596  gcm_context ctx;
14597  unsigned int key_len;
14598  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
14599  int ret;
14600 
14601  memset(key_str, 0x00, 128);
14602  memset(src_str, 0x00, 128);
14603  memset(dst_str, 0x00, 257);
14604  memset(iv_str, 0x00, 128);
14605  memset(add_str, 0x00, 128);
14606  memset(tag_str, 0x00, 128);
14607  memset(output, 0x00, 128);
14608 
14609  key_len = unhexify( key_str, "0bc344b1a4078807e5f53a6e7e1e36fa83108473ae2fb4c2" );
14610  pt_len = unhexify( src_str, "8bd73f94c71e3765bc7d17fdc90a9ba6aff9648b46300e4048985fbbd7c60c39c3766f7c524780bfc2296dc11e1132134921760a373104edc376eab6e91e9a60a5c4a5972935df12eadae074722bdc0147c3caf6a62fd449ef37d76b65f6d210283c94ac524cf13186e444d80a70b01e4373cc0462546f1caee6b49e738a742c" );
14611  iv_len = unhexify( iv_str, "bd505fcba464e6e2c58fdf29f5695fb9" );
14612  add_len = unhexify( add_str, "" );
14613  unhexify( tag_str, "8510fff71bb879f56ea2fe43f6ff50" );
14614 
14615  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14616  if( 0 == 0 )
14617  {
14618  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14619 
14620  if( strcmp( "FAIL", "FAIL" ) == 0 )
14621  {
14622  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14623  }
14624  else
14625  {
14626  hexify( dst_str, output, pt_len );
14627 
14628  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14629  }
14630  }
14631  }
14632  FCT_TEST_END();
14633 
14634 
14635  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240112_0)
14636  {
14637  unsigned char key_str[128];
14638  unsigned char src_str[128];
14639  unsigned char dst_str[257];
14640  unsigned char iv_str[128];
14641  unsigned char add_str[128];
14642  unsigned char tag_str[128];
14643  unsigned char output[128];
14644  gcm_context ctx;
14645  unsigned int key_len;
14646  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
14647  int ret;
14648 
14649  memset(key_str, 0x00, 128);
14650  memset(src_str, 0x00, 128);
14651  memset(dst_str, 0x00, 257);
14652  memset(iv_str, 0x00, 128);
14653  memset(add_str, 0x00, 128);
14654  memset(tag_str, 0x00, 128);
14655  memset(output, 0x00, 128);
14656 
14657  key_len = unhexify( key_str, "c8097398fc21f93eea6a95aa93a3231096817b65520bc549" );
14658  pt_len = unhexify( src_str, "80b0abbaebbd537a0810ed75cd172d29d50f5982e4d01f8664ddb2dfda8f57fa0ed87e64a779a1d7f5e568b6acfdc739572a7176752307b430fb1fa1c3c2c346477cebe7d01b16745ca6c8929a7f446c03ad9a9e8a5a935de78ca6c701e8c1c5e6d2550c42949cf5342fb5ef4c6ab9bb02ace8388b16edf72a1237e5d1d0e820" );
14659  iv_len = unhexify( iv_str, "776248381941e16908f52d19207881f5" );
14660  add_len = unhexify( add_str, "" );
14661  unhexify( tag_str, "7fc4388b2f8eab0f0c2d6a08527e" );
14662 
14663  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14664  if( 0 == 0 )
14665  {
14666  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14667 
14668  if( strcmp( "FAIL", "FAIL" ) == 0 )
14669  {
14670  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14671  }
14672  else
14673  {
14674  hexify( dst_str, output, pt_len );
14675 
14676  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14677  }
14678  }
14679  }
14680  FCT_TEST_END();
14681 
14682 
14683  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240112_1)
14684  {
14685  unsigned char key_str[128];
14686  unsigned char src_str[128];
14687  unsigned char dst_str[257];
14688  unsigned char iv_str[128];
14689  unsigned char add_str[128];
14690  unsigned char tag_str[128];
14691  unsigned char output[128];
14692  gcm_context ctx;
14693  unsigned int key_len;
14694  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
14695  int ret;
14696 
14697  memset(key_str, 0x00, 128);
14698  memset(src_str, 0x00, 128);
14699  memset(dst_str, 0x00, 257);
14700  memset(iv_str, 0x00, 128);
14701  memset(add_str, 0x00, 128);
14702  memset(tag_str, 0x00, 128);
14703  memset(output, 0x00, 128);
14704 
14705  key_len = unhexify( key_str, "76d4bb5694faaf344db83bc6d6c47d56bb6ab52700826f2d" );
14706  pt_len = unhexify( src_str, "9e31fda6a171f0d4a5f2af2c4f827b1312d9dda5d78fa329b8f1b6373b9b29be358601e5bb0d0c615aef4b9e441c811219f1f2ff2d0ab23e0cd829a88b5b615ee72e5e3ea604fa26cc6438ec4c30e90f7348e9116adf8e8efb7498320d2da16679fa546b1aa9afc7720b074c4e48e06862d41428c9e71a4772c2e195a6f36978" );
14707  iv_len = unhexify( iv_str, "603977845d82faccb401817ecce6e2fe" );
14708  add_len = unhexify( add_str, "" );
14709  unhexify( tag_str, "c955a3bc316841be07e406d289c8" );
14710 
14711  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14712  if( 0 == 0 )
14713  {
14714  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14715 
14716  if( strcmp( "FAIL", "FAIL" ) == 0 )
14717  {
14718  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14719  }
14720  else
14721  {
14722  hexify( dst_str, output, pt_len );
14723 
14724  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14725  }
14726  }
14727  }
14728  FCT_TEST_END();
14729 
14730 
14731  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240112_2)
14732  {
14733  unsigned char key_str[128];
14734  unsigned char src_str[128];
14735  unsigned char dst_str[257];
14736  unsigned char iv_str[128];
14737  unsigned char add_str[128];
14738  unsigned char tag_str[128];
14739  unsigned char output[128];
14740  gcm_context ctx;
14741  unsigned int key_len;
14742  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
14743  int ret;
14744 
14745  memset(key_str, 0x00, 128);
14746  memset(src_str, 0x00, 128);
14747  memset(dst_str, 0x00, 257);
14748  memset(iv_str, 0x00, 128);
14749  memset(add_str, 0x00, 128);
14750  memset(tag_str, 0x00, 128);
14751  memset(output, 0x00, 128);
14752 
14753  key_len = unhexify( key_str, "a3e5020695587984074d78d9c98b8e1a5719e5f88372740e" );
14754  pt_len = unhexify( src_str, "c0bfe3b2dc4dad17ec5a7662d86847fb67e582cc0baf469bc9baa7a075d48a8b97521a1072c2798bfbdae5ca3752eda1cb96fe5cf24af989eb77a2948aae3d8b70d83d93f84c49347f788480f34051621c358c03cf8159a70fc72cb8bc02876234ffe76b181da8b22b8796c87b0904da1af46de519c20d8d1b1dc7cc24e39ba5" );
14755  iv_len = unhexify( iv_str, "4cd56de54e5140a587be7dfd02d3a39e" );
14756  add_len = unhexify( add_str, "" );
14757  unhexify( tag_str, "1a29527a41330259f918d99d7509" );
14758 
14759  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14760  if( 0 == 0 )
14761  {
14762  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14763 
14764  if( strcmp( "FAIL", "FAIL" ) == 0 )
14765  {
14766  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14767  }
14768  else
14769  {
14770  hexify( dst_str, output, pt_len );
14771 
14772  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14773  }
14774  }
14775  }
14776  FCT_TEST_END();
14777 
14778 
14779  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240104_0)
14780  {
14781  unsigned char key_str[128];
14782  unsigned char src_str[128];
14783  unsigned char dst_str[257];
14784  unsigned char iv_str[128];
14785  unsigned char add_str[128];
14786  unsigned char tag_str[128];
14787  unsigned char output[128];
14788  gcm_context ctx;
14789  unsigned int key_len;
14790  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
14791  int ret;
14792 
14793  memset(key_str, 0x00, 128);
14794  memset(src_str, 0x00, 128);
14795  memset(dst_str, 0x00, 257);
14796  memset(iv_str, 0x00, 128);
14797  memset(add_str, 0x00, 128);
14798  memset(tag_str, 0x00, 128);
14799  memset(output, 0x00, 128);
14800 
14801  key_len = unhexify( key_str, "afe986ead799727063958e2ce13ca846f76c51605439f839" );
14802  pt_len = unhexify( src_str, "7c1b354a5bb214bd95147e32d81e658705089c38035d0ea423eb1a5c82f97443c6903d2cf1ba7a007eec7c8ff98b8f82b073d9636a79bd47c7f2f639a8eb4e92076f9ed615766f43ac3a4f1687301ed7d507766605e0e332880ae740ab72e861a2cb6dce1df1ff8be1873d25845ee7c665e712c5bbe029a1788634bce122836c" );
14803  iv_len = unhexify( iv_str, "f85a95ed10b69623162ab68d1098de94" );
14804  add_len = unhexify( add_str, "" );
14805  unhexify( tag_str, "3cf1cdb4a4fdc48da78a8b4e81" );
14806 
14807  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14808  if( 0 == 0 )
14809  {
14810  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14811 
14812  if( strcmp( "FAIL", "a7f252ad7983e7083260598051bffd83f40f4d4a8b580cc2388d720a0979dde71549ddcb86b0a62c4964fca591d0982f3a203f2f8884ff4991f17e20f759ea7125ba2bb4d993722f23938994eb2709c850f33ed9889e5a3966f9d7b76add46aedf230e8f417425f9db79ccd46b5660361de7c5d87f71a9d82c491c0c3daaf56c" ) == 0 )
14813  {
14814  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14815  }
14816  else
14817  {
14818  hexify( dst_str, output, pt_len );
14819 
14820  fct_chk( strcmp( (char *) dst_str, "a7f252ad7983e7083260598051bffd83f40f4d4a8b580cc2388d720a0979dde71549ddcb86b0a62c4964fca591d0982f3a203f2f8884ff4991f17e20f759ea7125ba2bb4d993722f23938994eb2709c850f33ed9889e5a3966f9d7b76add46aedf230e8f417425f9db79ccd46b5660361de7c5d87f71a9d82c491c0c3daaf56c" ) == 0 );
14821  }
14822  }
14823  }
14824  FCT_TEST_END();
14825 
14826 
14827  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240104_1)
14828  {
14829  unsigned char key_str[128];
14830  unsigned char src_str[128];
14831  unsigned char dst_str[257];
14832  unsigned char iv_str[128];
14833  unsigned char add_str[128];
14834  unsigned char tag_str[128];
14835  unsigned char output[128];
14836  gcm_context ctx;
14837  unsigned int key_len;
14838  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
14839  int ret;
14840 
14841  memset(key_str, 0x00, 128);
14842  memset(src_str, 0x00, 128);
14843  memset(dst_str, 0x00, 257);
14844  memset(iv_str, 0x00, 128);
14845  memset(add_str, 0x00, 128);
14846  memset(tag_str, 0x00, 128);
14847  memset(output, 0x00, 128);
14848 
14849  key_len = unhexify( key_str, "2cfaa215841826a977ae6adfdd993346210c49dd04d5d493" );
14850  pt_len = unhexify( src_str, "e8eb3b6edd0ca4201b49a6a83036445aba1a1db040f3e74511363bce769760a9914e05a067f555ca15a57c6e02e66fbe4e04dd8c8db8d6d14ebc01cc7d84a20ff0aacb69bb3679d6b7d9d2e07deda7c2d4fe4c584fe1166e78d21dc56b9cdad93709c03b9145b887f87b4f605f24f989d5e0534fc71a58e8a8619ee99f69e5f5" );
14851  iv_len = unhexify( iv_str, "537a4ee307af3072e745570aaaadce34" );
14852  add_len = unhexify( add_str, "" );
14853  unhexify( tag_str, "df01cffbd3978850e07328e6b8" );
14854 
14855  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14856  if( 0 == 0 )
14857  {
14858  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14859 
14860  if( strcmp( "FAIL", "FAIL" ) == 0 )
14861  {
14862  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14863  }
14864  else
14865  {
14866  hexify( dst_str, output, pt_len );
14867 
14868  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
14869  }
14870  }
14871  }
14872  FCT_TEST_END();
14873 
14874 
14875  FCT_TEST_BGN(gcm_nist_validation_aes_19212810240104_2)
14876  {
14877  unsigned char key_str[128];
14878  unsigned char src_str[128];
14879  unsigned char dst_str[257];
14880  unsigned char iv_str[128];
14881  unsigned char add_str[128];
14882  unsigned char tag_str[128];
14883  unsigned char output[128];
14884  gcm_context ctx;
14885  unsigned int key_len;
14886  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
14887  int ret;
14888 
14889  memset(key_str, 0x00, 128);
14890  memset(src_str, 0x00, 128);
14891  memset(dst_str, 0x00, 257);
14892  memset(iv_str, 0x00, 128);
14893  memset(add_str, 0x00, 128);
14894  memset(tag_str, 0x00, 128);
14895  memset(output, 0x00, 128);
14896 
14897  key_len = unhexify( key_str, "128ddc83d2170c403a517615056dceec0d19d6fd7632e738" );
14898  pt_len = unhexify( src_str, "cfe9f7797ee37bfc4f564419bf2268c964479efa7435970874154432930f3b2736438da4dc9c76200009651340e23044bc9d200a32acfd4df2e1b98b0bae3e9ff9d6e8181d926d2d03f89768edc35b963d341931ac57d2739b270ce254f042b64ceac4b75223b233602c9a4bdc925967b051440c28805d816abe76fc9d593f5a" );
14899  iv_len = unhexify( iv_str, "5124b410c43d875eca6ce298c45994a7" );
14900  add_len = unhexify( add_str, "" );
14901  unhexify( tag_str, "56ad9c1653f11a41fd649cccd8" );
14902 
14903  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14904  if( 0 == 0 )
14905  {
14906  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14907 
14908  if( strcmp( "FAIL", "cf91f087fd7faf362caacf4a68cff51ec57b3075563e4ad0955df20b366e92bd75c3762cf4a6f0eb859872667a5c55aa5d94f5ac9479b1b9c9345b50f82379d551506a2ab02b0441b14b28b78a12b38500d703a8c19888fe612d4710eec7cd18c16d6a4b55d3c69760e2bed99efc8b551dbe2ac9b9b64715f87180b8e14d1795" ) == 0 )
14909  {
14910  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14911  }
14912  else
14913  {
14914  hexify( dst_str, output, pt_len );
14915 
14916  fct_chk( strcmp( (char *) dst_str, "cf91f087fd7faf362caacf4a68cff51ec57b3075563e4ad0955df20b366e92bd75c3762cf4a6f0eb859872667a5c55aa5d94f5ac9479b1b9c9345b50f82379d551506a2ab02b0441b14b28b78a12b38500d703a8c19888fe612d4710eec7cd18c16d6a4b55d3c69760e2bed99efc8b551dbe2ac9b9b64715f87180b8e14d1795" ) == 0 );
14917  }
14918  }
14919  }
14920  FCT_TEST_END();
14921 
14922 
14923  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024096_0)
14924  {
14925  unsigned char key_str[128];
14926  unsigned char src_str[128];
14927  unsigned char dst_str[257];
14928  unsigned char iv_str[128];
14929  unsigned char add_str[128];
14930  unsigned char tag_str[128];
14931  unsigned char output[128];
14932  gcm_context ctx;
14933  unsigned int key_len;
14934  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
14935  int ret;
14936 
14937  memset(key_str, 0x00, 128);
14938  memset(src_str, 0x00, 128);
14939  memset(dst_str, 0x00, 257);
14940  memset(iv_str, 0x00, 128);
14941  memset(add_str, 0x00, 128);
14942  memset(tag_str, 0x00, 128);
14943  memset(output, 0x00, 128);
14944 
14945  key_len = unhexify( key_str, "98581c28983c4da321ce0c419cc0d476d539e77da513c894" );
14946  pt_len = unhexify( src_str, "bdef5b65b5111b29e781a6b71a0160179c52b5bccb1ac5c0377b26cf3f61432f3ccd67633a836357c24b5099db0510a7f8110f59e8227cacd11f17ea1798b5d4d68902ca6c6eccd319fef14545edd135078b38d43b61c9af269fc72f7a209ba7897e4c6dbd21bb71d7e93d2d2426ffa1557cae28e74059d3baf06ba419a47b39" );
14947  iv_len = unhexify( iv_str, "ff10234524433b871202c2cca6acb194" );
14948  add_len = unhexify( add_str, "" );
14949  unhexify( tag_str, "984943355a7aef15c4fb8033" );
14950 
14951  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
14952  if( 0 == 0 )
14953  {
14954  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
14955 
14956  if( strcmp( "FAIL", "808e28bfd441cb8890416a757d252c986daa8d607ac9cadd2f4fd29eddbcf3b859ba298e14a4ccefe2c2752b123f87b98d6708fde48faca4bc7dd818a7ea76cfa4357932e59cb6be0e9283bdfb49454b86b9fd04aa8cdef503c65d13fcff42e9cd8f142f8c06cf7daa6d8ef8b9c9d69c39e8afd980048fecf731fd674b2a814b" ) == 0 )
14957  {
14958  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
14959  }
14960  else
14961  {
14962  hexify( dst_str, output, pt_len );
14963 
14964  fct_chk( strcmp( (char *) dst_str, "808e28bfd441cb8890416a757d252c986daa8d607ac9cadd2f4fd29eddbcf3b859ba298e14a4ccefe2c2752b123f87b98d6708fde48faca4bc7dd818a7ea76cfa4357932e59cb6be0e9283bdfb49454b86b9fd04aa8cdef503c65d13fcff42e9cd8f142f8c06cf7daa6d8ef8b9c9d69c39e8afd980048fecf731fd674b2a814b" ) == 0 );
14965  }
14966  }
14967  }
14968  FCT_TEST_END();
14969 
14970 
14971  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024096_1)
14972  {
14973  unsigned char key_str[128];
14974  unsigned char src_str[128];
14975  unsigned char dst_str[257];
14976  unsigned char iv_str[128];
14977  unsigned char add_str[128];
14978  unsigned char tag_str[128];
14979  unsigned char output[128];
14980  gcm_context ctx;
14981  unsigned int key_len;
14982  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
14983  int ret;
14984 
14985  memset(key_str, 0x00, 128);
14986  memset(src_str, 0x00, 128);
14987  memset(dst_str, 0x00, 257);
14988  memset(iv_str, 0x00, 128);
14989  memset(add_str, 0x00, 128);
14990  memset(tag_str, 0x00, 128);
14991  memset(output, 0x00, 128);
14992 
14993  key_len = unhexify( key_str, "167b8b6df8014c8f3de912b77f5a0c113580aa42d785298f" );
14994  pt_len = unhexify( src_str, "4f787de12ba907a589edf74c8e7a6cdaaabebddd465a86e170e1efc289240298b516fddc43c7fd9bb1c51720a4455db4dd630b59aebaa82bd578eb3cb19f8b23ee6897c1fefaef820430efa6eb7d6ff04de4d8b079605fb520b0d33e96c28f0cd71983c4ce76c0ea62fd7209d21ec7b416881d545824a73d1f9f8d3323fdb90c" );
14995  iv_len = unhexify( iv_str, "49da91e926091a448d57d521cc90f3c0" );
14996  add_len = unhexify( add_str, "" );
14997  unhexify( tag_str, "99198f55f9fa763651bba58e" );
14998 
14999  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15000  if( 0 == 0 )
15001  {
15002  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15003 
15004  if( strcmp( "FAIL", "FAIL" ) == 0 )
15005  {
15006  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15007  }
15008  else
15009  {
15010  hexify( dst_str, output, pt_len );
15011 
15012  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15013  }
15014  }
15015  }
15016  FCT_TEST_END();
15017 
15018 
15019  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024096_2)
15020  {
15021  unsigned char key_str[128];
15022  unsigned char src_str[128];
15023  unsigned char dst_str[257];
15024  unsigned char iv_str[128];
15025  unsigned char add_str[128];
15026  unsigned char tag_str[128];
15027  unsigned char output[128];
15028  gcm_context ctx;
15029  unsigned int key_len;
15030  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
15031  int ret;
15032 
15033  memset(key_str, 0x00, 128);
15034  memset(src_str, 0x00, 128);
15035  memset(dst_str, 0x00, 257);
15036  memset(iv_str, 0x00, 128);
15037  memset(add_str, 0x00, 128);
15038  memset(tag_str, 0x00, 128);
15039  memset(output, 0x00, 128);
15040 
15041  key_len = unhexify( key_str, "71f5f8505fba62f08fa0557dd5407fc83a852c6007ccecc8" );
15042  pt_len = unhexify( src_str, "3e19ec02365e450e946123a3362f9859352eb52902a6bcb8a782285dfac9d2b282f56302b60d6e9f53fddd16bbf04976cf4eb84ef3b6583e9dc2f805276a7b7340dec7abde4916fb94b0ed9c9af6d4917b27e44d25f3952d0444cd32a4a574e165a23fa8c93229ceb48345171a4f20d610b5be7d9e40dcf7209128f029fed6bf" );
15043  iv_len = unhexify( iv_str, "b5efb9feae3de41b5ce9aa75583b8d21" );
15044  add_len = unhexify( add_str, "" );
15045  unhexify( tag_str, "9604d031fa43dcd0853e641c" );
15046 
15047  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15048  if( 0 == 0 )
15049  {
15050  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15051 
15052  if( strcmp( "FAIL", "FAIL" ) == 0 )
15053  {
15054  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15055  }
15056  else
15057  {
15058  hexify( dst_str, output, pt_len );
15059 
15060  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15061  }
15062  }
15063  }
15064  FCT_TEST_END();
15065 
15066 
15067  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024064_0)
15068  {
15069  unsigned char key_str[128];
15070  unsigned char src_str[128];
15071  unsigned char dst_str[257];
15072  unsigned char iv_str[128];
15073  unsigned char add_str[128];
15074  unsigned char tag_str[128];
15075  unsigned char output[128];
15076  gcm_context ctx;
15077  unsigned int key_len;
15078  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
15079  int ret;
15080 
15081  memset(key_str, 0x00, 128);
15082  memset(src_str, 0x00, 128);
15083  memset(dst_str, 0x00, 257);
15084  memset(iv_str, 0x00, 128);
15085  memset(add_str, 0x00, 128);
15086  memset(tag_str, 0x00, 128);
15087  memset(output, 0x00, 128);
15088 
15089  key_len = unhexify( key_str, "4cdb38f8185a4186fc983e58a776a6454b92ecf0bffefe98" );
15090  pt_len = unhexify( src_str, "1ca72c50a093076e9a9dfa09888b9c89eb36a942072fc536a81713f05a2669b39fdb2871b82ca47dcaf18393ca81dcb499aafcc4ed57ea79f8d4f9bd63540610215b2c65481b294638cec41264a7fdca4230df5fe1e7e3d8d26dcd0c435fec8e9bf778f9e6f13482157a9722761601e08425f6160d3bb626ae39ee1117b0353c" );
15091  iv_len = unhexify( iv_str, "aef257dd44d14d0bc75f9311ef24e85a" );
15092  add_len = unhexify( add_str, "" );
15093  unhexify( tag_str, "d951becb0d55f9fb" );
15094 
15095  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15096  if( 0 == 0 )
15097  {
15098  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15099 
15100  if( strcmp( "FAIL", "2eaa7e922dbd8963e2078aae216636276f3f7cb5d7f35fa759e91bddb6e247a93c388241ba1d0d37040c0b9e447c67d35b4991c1acce97914f3bc22ee50171bc5922299983ee70af79303265bc1ae1e7334202460618b4a8891d1a7eaaac5cac1e4dce024ce662d14849993f89e771fb873644b552120fd346250df39aaaa403" ) == 0 )
15101  {
15102  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15103  }
15104  else
15105  {
15106  hexify( dst_str, output, pt_len );
15107 
15108  fct_chk( strcmp( (char *) dst_str, "2eaa7e922dbd8963e2078aae216636276f3f7cb5d7f35fa759e91bddb6e247a93c388241ba1d0d37040c0b9e447c67d35b4991c1acce97914f3bc22ee50171bc5922299983ee70af79303265bc1ae1e7334202460618b4a8891d1a7eaaac5cac1e4dce024ce662d14849993f89e771fb873644b552120fd346250df39aaaa403" ) == 0 );
15109  }
15110  }
15111  }
15112  FCT_TEST_END();
15113 
15114 
15115  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024064_1)
15116  {
15117  unsigned char key_str[128];
15118  unsigned char src_str[128];
15119  unsigned char dst_str[257];
15120  unsigned char iv_str[128];
15121  unsigned char add_str[128];
15122  unsigned char tag_str[128];
15123  unsigned char output[128];
15124  gcm_context ctx;
15125  unsigned int key_len;
15126  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
15127  int ret;
15128 
15129  memset(key_str, 0x00, 128);
15130  memset(src_str, 0x00, 128);
15131  memset(dst_str, 0x00, 257);
15132  memset(iv_str, 0x00, 128);
15133  memset(add_str, 0x00, 128);
15134  memset(tag_str, 0x00, 128);
15135  memset(output, 0x00, 128);
15136 
15137  key_len = unhexify( key_str, "ee8d3aced3aa3cb2166aa66c4a252c12dc0978830d0bc75b" );
15138  pt_len = unhexify( src_str, "ee69b2421d43a9f383d99f9802ba4d6cf1c537b42041c86cce681049bb475e5098d4181f1902b0a49c202bf34ef70ea7b787fa685ab8f824fcc27282146d8158925bfef47ccba89aa81c0565eacb087b46b8706c9f886b7edf863701003051d6fb57e45e61d33412591ec818d016eec7dee4254636615a43dacb4f1e6ec35702" );
15139  iv_len = unhexify( iv_str, "c15c9c0b0b70c7321df044bfde2b15fb" );
15140  add_len = unhexify( add_str, "" );
15141  unhexify( tag_str, "c5c9851a6bf686d0" );
15142 
15143  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15144  if( 0 == 0 )
15145  {
15146  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15147 
15148  if( strcmp( "FAIL", "FAIL" ) == 0 )
15149  {
15150  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15151  }
15152  else
15153  {
15154  hexify( dst_str, output, pt_len );
15155 
15156  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15157  }
15158  }
15159  }
15160  FCT_TEST_END();
15161 
15162 
15163  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024064_2)
15164  {
15165  unsigned char key_str[128];
15166  unsigned char src_str[128];
15167  unsigned char dst_str[257];
15168  unsigned char iv_str[128];
15169  unsigned char add_str[128];
15170  unsigned char tag_str[128];
15171  unsigned char output[128];
15172  gcm_context ctx;
15173  unsigned int key_len;
15174  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
15175  int ret;
15176 
15177  memset(key_str, 0x00, 128);
15178  memset(src_str, 0x00, 128);
15179  memset(dst_str, 0x00, 257);
15180  memset(iv_str, 0x00, 128);
15181  memset(add_str, 0x00, 128);
15182  memset(tag_str, 0x00, 128);
15183  memset(output, 0x00, 128);
15184 
15185  key_len = unhexify( key_str, "4a8538d609444e3197ab740cd33b66db1cf53600096b94e0" );
15186  pt_len = unhexify( src_str, "8c2b8fb775d1b21c41a3dcf48ad6d68ab05be3879f9b94b305a6ce4d799e3a992c1c3a65a3e4eab563edb57424927c90c76e49386e29dd5e7de2800fcc0eefbc8b4f977f71be3754c006ee93dc09b1cfa59c424b6b3987aeb56feefc21004c63e8284b6845e395bc8843cca0917267fb4a8f2db1f7daafe7a9da95083a44de70" );
15187  iv_len = unhexify( iv_str, "0bd64d222532dae8ab63dc299355bf2a" );
15188  add_len = unhexify( add_str, "" );
15189  unhexify( tag_str, "3477cad1fd4098b2" );
15190 
15191  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15192  if( 0 == 0 )
15193  {
15194  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15195 
15196  if( strcmp( "FAIL", "FAIL" ) == 0 )
15197  {
15198  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15199  }
15200  else
15201  {
15202  hexify( dst_str, output, pt_len );
15203 
15204  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15205  }
15206  }
15207  }
15208  FCT_TEST_END();
15209 
15210 
15211  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024032_0)
15212  {
15213  unsigned char key_str[128];
15214  unsigned char src_str[128];
15215  unsigned char dst_str[257];
15216  unsigned char iv_str[128];
15217  unsigned char add_str[128];
15218  unsigned char tag_str[128];
15219  unsigned char output[128];
15220  gcm_context ctx;
15221  unsigned int key_len;
15222  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
15223  int ret;
15224 
15225  memset(key_str, 0x00, 128);
15226  memset(src_str, 0x00, 128);
15227  memset(dst_str, 0x00, 257);
15228  memset(iv_str, 0x00, 128);
15229  memset(add_str, 0x00, 128);
15230  memset(tag_str, 0x00, 128);
15231  memset(output, 0x00, 128);
15232 
15233  key_len = unhexify( key_str, "447f0f065771b6129952e52206a64fe0844658ed685e39cd" );
15234  pt_len = unhexify( src_str, "fea5d227869e527882c63a68a6623f4a699df82b3dc715c7260a5554336df8376744c05ae89ec27d40da02d9f1c5e9e29405579fd4132143cb21cdbe3edfaaab62128ecc28018725c8dd309d2376223d2e2edfea9765699b2630ff5d9fe9bec416c0ca6418b938d195d31a08e4034c49d79e3a249edd65f985230b33c444dd02" );
15235  iv_len = unhexify( iv_str, "37e3a300542d9caf3975c6429cb8a2e8" );
15236  add_len = unhexify( add_str, "" );
15237  unhexify( tag_str, "06bfca29" );
15238 
15239  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15240  if( 0 == 0 )
15241  {
15242  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15243 
15244  if( strcmp( "FAIL", "e1bdd1c212b159b87e41a5f64dcba6b27aa0f5c8871fabfb588df0e06bd7730ec1beb0e3388f96c992a573ff69b34870f83c53fb65b420c1c6f92e2aa6f03917e8203d77c7f5ee08baf9fab12f9d38fc0ffb83807ba781c3dd7b62edca2121f68ef230b42b8adbd4cea072209d02713789ed559b83739a54cfde69e68bdc4128" ) == 0 )
15245  {
15246  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15247  }
15248  else
15249  {
15250  hexify( dst_str, output, pt_len );
15251 
15252  fct_chk( strcmp( (char *) dst_str, "e1bdd1c212b159b87e41a5f64dcba6b27aa0f5c8871fabfb588df0e06bd7730ec1beb0e3388f96c992a573ff69b34870f83c53fb65b420c1c6f92e2aa6f03917e8203d77c7f5ee08baf9fab12f9d38fc0ffb83807ba781c3dd7b62edca2121f68ef230b42b8adbd4cea072209d02713789ed559b83739a54cfde69e68bdc4128" ) == 0 );
15253  }
15254  }
15255  }
15256  FCT_TEST_END();
15257 
15258 
15259  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024032_1)
15260  {
15261  unsigned char key_str[128];
15262  unsigned char src_str[128];
15263  unsigned char dst_str[257];
15264  unsigned char iv_str[128];
15265  unsigned char add_str[128];
15266  unsigned char tag_str[128];
15267  unsigned char output[128];
15268  gcm_context ctx;
15269  unsigned int key_len;
15270  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
15271  int ret;
15272 
15273  memset(key_str, 0x00, 128);
15274  memset(src_str, 0x00, 128);
15275  memset(dst_str, 0x00, 257);
15276  memset(iv_str, 0x00, 128);
15277  memset(add_str, 0x00, 128);
15278  memset(tag_str, 0x00, 128);
15279  memset(output, 0x00, 128);
15280 
15281  key_len = unhexify( key_str, "f465e95f6fc19fe6968b98319b547104d0c01c17105f8fc0" );
15282  pt_len = unhexify( src_str, "2426f108368a00d2a49670a3b64b4f0569c6da9660163e7b209ec3f8d058ee11f7818a8c5030c5f4ce6e1e5a93faa3e5ae3d0bd5d712fbc891cfeb20845707edcf5e29719a5246a3b024fb12d37bd1b81df3812fd50b1dfb3e948ce546dd165cc77f903c07fe32bc7da7fbc25036679017317ce94cd8a00c1bce7379774f1714" );
15283  iv_len = unhexify( iv_str, "6cba4efc8d4840aa044a92d03d6b4d69" );
15284  add_len = unhexify( add_str, "" );
15285  unhexify( tag_str, "92750ac9" );
15286 
15287  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15288  if( 0 == 0 )
15289  {
15290  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15291 
15292  if( strcmp( "FAIL", "2e59b104c1a6f6d651000396adbfa009bf4cf8cbf714da8e4d3b4a62bd7f522d614decf090c7552a4b9e8d7ee457ba642d5100c0c81c14cbba8c8ff49b12827f6ebd41504ccb6dfc97cdf8532d1f7f7e603c609efa72d2ae0dce036ec4ab36849a0c06f8737d9710075a1daaed3867ca0a7e22111c0e7afae91f553b6fd66c6e" ) == 0 )
15293  {
15294  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15295  }
15296  else
15297  {
15298  hexify( dst_str, output, pt_len );
15299 
15300  fct_chk( strcmp( (char *) dst_str, "2e59b104c1a6f6d651000396adbfa009bf4cf8cbf714da8e4d3b4a62bd7f522d614decf090c7552a4b9e8d7ee457ba642d5100c0c81c14cbba8c8ff49b12827f6ebd41504ccb6dfc97cdf8532d1f7f7e603c609efa72d2ae0dce036ec4ab36849a0c06f8737d9710075a1daaed3867ca0a7e22111c0e7afae91f553b6fd66c6e" ) == 0 );
15301  }
15302  }
15303  }
15304  FCT_TEST_END();
15305 
15306 
15307  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024032_2)
15308  {
15309  unsigned char key_str[128];
15310  unsigned char src_str[128];
15311  unsigned char dst_str[257];
15312  unsigned char iv_str[128];
15313  unsigned char add_str[128];
15314  unsigned char tag_str[128];
15315  unsigned char output[128];
15316  gcm_context ctx;
15317  unsigned int key_len;
15318  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
15319  int ret;
15320 
15321  memset(key_str, 0x00, 128);
15322  memset(src_str, 0x00, 128);
15323  memset(dst_str, 0x00, 257);
15324  memset(iv_str, 0x00, 128);
15325  memset(add_str, 0x00, 128);
15326  memset(tag_str, 0x00, 128);
15327  memset(output, 0x00, 128);
15328 
15329  key_len = unhexify( key_str, "f08e3e9f7b3a20ccdc4d98b56f2b567399a28a6b3908deab" );
15330  pt_len = unhexify( src_str, "a986e816f1eafb532c716a555cca1839a1b0523410134ea0426ab309520b339fc1fdeb40478ae76823cee4e03b8d3450e6be92d5ff17b2f78400f0176e6d6a3930bd076a7a3c87c3397dcc0520c6b7b4ff9059ea21e71c91912a74aac2ca70eec422b507cc5c60860bb8baca01eec2a3003970ba84011efe576804b2820e306c" );
15331  iv_len = unhexify( iv_str, "4f4636d1b283bfa72c82809eb4f12519" );
15332  add_len = unhexify( add_str, "" );
15333  unhexify( tag_str, "16c80a62" );
15334 
15335  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15336  if( 0 == 0 )
15337  {
15338  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15339 
15340  if( strcmp( "FAIL", "FAIL" ) == 0 )
15341  {
15342  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15343  }
15344  else
15345  {
15346  hexify( dst_str, output, pt_len );
15347 
15348  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15349  }
15350  }
15351  }
15352  FCT_TEST_END();
15353 
15354 
15355  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024128_0)
15356  {
15357  unsigned char key_str[128];
15358  unsigned char src_str[128];
15359  unsigned char dst_str[257];
15360  unsigned char iv_str[128];
15361  unsigned char add_str[128];
15362  unsigned char tag_str[128];
15363  unsigned char output[128];
15364  gcm_context ctx;
15365  unsigned int key_len;
15366  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
15367  int ret;
15368 
15369  memset(key_str, 0x00, 128);
15370  memset(src_str, 0x00, 128);
15371  memset(dst_str, 0x00, 257);
15372  memset(iv_str, 0x00, 128);
15373  memset(add_str, 0x00, 128);
15374  memset(tag_str, 0x00, 128);
15375  memset(output, 0x00, 128);
15376 
15377  key_len = unhexify( key_str, "87b5372571fb244648053c99405999130f87a7c178052297" );
15378  pt_len = unhexify( src_str, "ae078d1554fc6a14447a28c3dd753e790f7ef9b53e35c3e0fe63a7b1b326bc56034847f8a31c2d6358049aae990bfe7575b439db370aa515e225e0ec730488c700a7b0a96a7b8e4e8e4c6afec20decd16fe3c0f3f8d7a6cf7a8711d170829d14c706cceb00e133b8c65c8e08cd984b884662eddd2258ce629abf6b9dd28688c9" );
15379  iv_len = unhexify( iv_str, "a1cc81b87bd36affe3af50546e361c9e" );
15380  add_len = unhexify( add_str, "684ce23f59632308d7db14f7f6eddaf4d83271fb0c27401b09518a775b36252540f14305f0dae13ff6c0dc565c9e570759e070c8ac73dfb97abd3285689a7cdcfc941f6271be3b418740b42ba4a114421065a785be3dfa944c86af56da8209779e8736e62529c418b507c6d8ae002cbc0431747722afd64521734f99273de455" );
15381  unhexify( tag_str, "98177b3428e64bc98631375905c0100f" );
15382 
15383  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15384  if( 0 == 0 )
15385  {
15386  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15387 
15388  if( strcmp( "FAIL", "8be7df33a86b1162464af738de582a357d0ce8e213bba1b7913c0d13ad759d62c3bf4366f5130b3af2b255b7ad530b4977627f9e76b07e360c079d0f763dabbd22e976b98cd5495c6182f95bc963aad4b719446f49d3a448d11cac5bfcba4b675b8e4d88a389e2580e8f383f95bf85c72e698680d2a2bc993c9ee1ce0d1f1ac3" ) == 0 )
15389  {
15390  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15391  }
15392  else
15393  {
15394  hexify( dst_str, output, pt_len );
15395 
15396  fct_chk( strcmp( (char *) dst_str, "8be7df33a86b1162464af738de582a357d0ce8e213bba1b7913c0d13ad759d62c3bf4366f5130b3af2b255b7ad530b4977627f9e76b07e360c079d0f763dabbd22e976b98cd5495c6182f95bc963aad4b719446f49d3a448d11cac5bfcba4b675b8e4d88a389e2580e8f383f95bf85c72e698680d2a2bc993c9ee1ce0d1f1ac3" ) == 0 );
15397  }
15398  }
15399  }
15400  FCT_TEST_END();
15401 
15402 
15403  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024128_1)
15404  {
15405  unsigned char key_str[128];
15406  unsigned char src_str[128];
15407  unsigned char dst_str[257];
15408  unsigned char iv_str[128];
15409  unsigned char add_str[128];
15410  unsigned char tag_str[128];
15411  unsigned char output[128];
15412  gcm_context ctx;
15413  unsigned int key_len;
15414  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
15415  int ret;
15416 
15417  memset(key_str, 0x00, 128);
15418  memset(src_str, 0x00, 128);
15419  memset(dst_str, 0x00, 257);
15420  memset(iv_str, 0x00, 128);
15421  memset(add_str, 0x00, 128);
15422  memset(tag_str, 0x00, 128);
15423  memset(output, 0x00, 128);
15424 
15425  key_len = unhexify( key_str, "a2d069b826455d5e79e65db4f1d2b6a29ae9f401bc623917" );
15426  pt_len = unhexify( src_str, "acd6225dc5b9109d56ea565ab38dd4db432a7ec08f0db04f1c6b691c96d2eaaa6be62da7cc7fd75f931716c7f39705ea7cf828f1a5a325955e9b2c77e7fb2d562be6a89b3351b1b3d1355b43b73ed425049430314c16bf0836ed580e9390a3b8e2a652fddbfa939ca4c3c99765b09db7f30bf2ef88e1aa030e68958722cb0da3" );
15427  iv_len = unhexify( iv_str, "6d40a0c7813bc0410ff73f19bb5d89c9" );
15428  add_len = unhexify( add_str, "9960376b1898618d98c327c1761959d045488cc6198238bbe72662f276d47b41e8aebc06dbce63da5adcb302a61ade140c72b9cf9f6dfad6ecedd7401c9509fae349d3c7debe35117776227ba167f2b75921d7321d79f4ebca13d20af1638a1567043365f179f4162795fe4fd80b5d832e4ca70e7bf9830bc272b82182f70d2e" );
15429  unhexify( tag_str, "010195091d4e1684029e58439039d91e" );
15430 
15431  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15432  if( 0 == 0 )
15433  {
15434  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15435 
15436  if( strcmp( "FAIL", "FAIL" ) == 0 )
15437  {
15438  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15439  }
15440  else
15441  {
15442  hexify( dst_str, output, pt_len );
15443 
15444  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15445  }
15446  }
15447  }
15448  FCT_TEST_END();
15449 
15450 
15451  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024128_2)
15452  {
15453  unsigned char key_str[128];
15454  unsigned char src_str[128];
15455  unsigned char dst_str[257];
15456  unsigned char iv_str[128];
15457  unsigned char add_str[128];
15458  unsigned char tag_str[128];
15459  unsigned char output[128];
15460  gcm_context ctx;
15461  unsigned int key_len;
15462  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
15463  int ret;
15464 
15465  memset(key_str, 0x00, 128);
15466  memset(src_str, 0x00, 128);
15467  memset(dst_str, 0x00, 257);
15468  memset(iv_str, 0x00, 128);
15469  memset(add_str, 0x00, 128);
15470  memset(tag_str, 0x00, 128);
15471  memset(output, 0x00, 128);
15472 
15473  key_len = unhexify( key_str, "f3252351fe8e7c628c418c1a49709bf1f8e20add82539948" );
15474  pt_len = unhexify( src_str, "7e8d2816d280c91d232bad43b6610e2d0532a9f670f221a3a975fb16472c2e83b168115e87a487bcd14b37f075e1faa59c42515c353cdefc728ac617b7d273fa96778e3fb5f7a1132f8e2add4a57015b15d1984338b7862356243d1c5aa628406f4a507498eda12d2f652c55e8e58113ed828783b82505790654f036b610f89a" );
15475  iv_len = unhexify( iv_str, "eacd2b1c3cf01bf4ea7582d8ee2675d5" );
15476  add_len = unhexify( add_str, "141cb39a2fb8e735e0c97207f1b618a4b98f6b9bf8c44a1c8e9ea575a7759cc2a02301274553e7744408b2c577b4c8c2a00e18f8717fd8a6d2f46a44eeb05d685fbef7edeb4229e7ea9b8e419ffcb504d33583b3ae421c84caeca9f9789047dd7b1810318d3765307233567bc40e003401c9f4e1b07a2a7162889e1a092aedc1" );
15477  unhexify( tag_str, "63a310b4f43b421a863fb00fafd7eac4" );
15478 
15479  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15480  if( 0 == 0 )
15481  {
15482  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15483 
15484  if( strcmp( "FAIL", "699c146927ae29025e5b20088b20af27bc75449e4725ee6b7d5dc60b44ba8a06f7d265330c16060fbd6def244630d056c82676be2dc85d891c63d005804085c93ce88f3f57c2d2c0371c31027d0a4a0031e3f473cb373db63d4ff8f65be9ebe74045de813a4e6c688110d000f6b12406881c08085c9348e1f0315038907e33f7" ) == 0 )
15485  {
15486  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15487  }
15488  else
15489  {
15490  hexify( dst_str, output, pt_len );
15491 
15492  fct_chk( strcmp( (char *) dst_str, "699c146927ae29025e5b20088b20af27bc75449e4725ee6b7d5dc60b44ba8a06f7d265330c16060fbd6def244630d056c82676be2dc85d891c63d005804085c93ce88f3f57c2d2c0371c31027d0a4a0031e3f473cb373db63d4ff8f65be9ebe74045de813a4e6c688110d000f6b12406881c08085c9348e1f0315038907e33f7" ) == 0 );
15493  }
15494  }
15495  }
15496  FCT_TEST_END();
15497 
15498 
15499  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024120_0)
15500  {
15501  unsigned char key_str[128];
15502  unsigned char src_str[128];
15503  unsigned char dst_str[257];
15504  unsigned char iv_str[128];
15505  unsigned char add_str[128];
15506  unsigned char tag_str[128];
15507  unsigned char output[128];
15508  gcm_context ctx;
15509  unsigned int key_len;
15510  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
15511  int ret;
15512 
15513  memset(key_str, 0x00, 128);
15514  memset(src_str, 0x00, 128);
15515  memset(dst_str, 0x00, 257);
15516  memset(iv_str, 0x00, 128);
15517  memset(add_str, 0x00, 128);
15518  memset(tag_str, 0x00, 128);
15519  memset(output, 0x00, 128);
15520 
15521  key_len = unhexify( key_str, "e462957f2c500bf2d6bfa9af97938fdd8930e360ea4175e7" );
15522  pt_len = unhexify( src_str, "82a7a6dd82a5ea3d9a8e9541d854978487eda298b483df02b45c76b8b38bac98ffd969dd160a2765595b19d4ea3e64351ce95764a903f595dd673d13facf5a5594e01be1d60a0c6d28b866a1f93a63a74fecb6d73ac6fb26b20c008b93db53e9dc1d3e3902359fd47734fe22a5c6958f97e9001cc4e8b6484d9542dbbdfcfcdc" );
15523  iv_len = unhexify( iv_str, "b380584a3f4e0e59add4753c282f2cf7" );
15524  add_len = unhexify( add_str, "682b0af6592eef173e559407e7f56574c069251b92092570cbb7f5a2f05e88bed0af48dcda45b2930b1ee7d5da78dc43ec3598a38593df7c548058eda3c9275c1304489aff95f33a6cd79e724e8d12ca0ae92b20273eb3736efcd50dc49e803ad631dcbf64376a45a687eb4e417aef08a3f5f8230d3f0b266ea732c21ed2eed7" );
15525  unhexify( tag_str, "28a43253d8b37795433140641e9ffd" );
15526 
15527  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15528  if( 0 == 0 )
15529  {
15530  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15531 
15532  if( strcmp( "FAIL", "FAIL" ) == 0 )
15533  {
15534  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15535  }
15536  else
15537  {
15538  hexify( dst_str, output, pt_len );
15539 
15540  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15541  }
15542  }
15543  }
15544  FCT_TEST_END();
15545 
15546 
15547  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024120_1)
15548  {
15549  unsigned char key_str[128];
15550  unsigned char src_str[128];
15551  unsigned char dst_str[257];
15552  unsigned char iv_str[128];
15553  unsigned char add_str[128];
15554  unsigned char tag_str[128];
15555  unsigned char output[128];
15556  gcm_context ctx;
15557  unsigned int key_len;
15558  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
15559  int ret;
15560 
15561  memset(key_str, 0x00, 128);
15562  memset(src_str, 0x00, 128);
15563  memset(dst_str, 0x00, 257);
15564  memset(iv_str, 0x00, 128);
15565  memset(add_str, 0x00, 128);
15566  memset(tag_str, 0x00, 128);
15567  memset(output, 0x00, 128);
15568 
15569  key_len = unhexify( key_str, "4a62ddd87f41c6df756e8da0985dcd8c91e73ba395b3d79b" );
15570  pt_len = unhexify( src_str, "37a83ee6dbdece212446739ea353cb957b9aa409c88bee042bbc3a6e5199aeb28f2b4b00ff433c0c68d6db5a197566019db8a4c7a792e2839a19a302ee02bee046adce04c1fbbd5b0c457d7cbe277992ce2c153d132269e2d1f12b084cf3026a202b4664bc9d11832e9b99c7cc5035dcfde5991dd41aeb4fbf8bec5126a9f524" );
15571  iv_len = unhexify( iv_str, "1d1843e2118772d76a0244a2c33c60bd" );
15572  add_len = unhexify( add_str, "028b92727b75b14cb8dfeb7a86a7fec50cd5de46aa4a34645754918b8606819d4bf8a2e7531a05ae5505492ca6cbc8c0e6d6ab2dea23bff1fdf581bb780b4a3312aa39639383fd10bcf92489801954733f16b021c2e84809345216f8f28a99773341e40c4a64305a2098eaa39f26a93bd556c97f02090e1a6c181a4e13e17d3a" );
15573  unhexify( tag_str, "ab738073228bdf1e8fd4430b5c7d79" );
15574 
15575  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15576  if( 0 == 0 )
15577  {
15578  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15579 
15580  if( strcmp( "FAIL", "e702f1bb9a1f395c74fca0ce9cdf29e7332c14acaca45200cd432a5767be38929ef8de43d0e1a5e7300c1eb669ac1ab997b31cb1403af8451e77e63505920af0f8c3abf5a9450ea47371039ba1cf2d65a14fa5f013b7ce1d175859404dcf6461a36e8bc260e7abf739d8951ddf1a3754e2d65e0aa31320a5ffca822023bc0906" ) == 0 )
15581  {
15582  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15583  }
15584  else
15585  {
15586  hexify( dst_str, output, pt_len );
15587 
15588  fct_chk( strcmp( (char *) dst_str, "e702f1bb9a1f395c74fca0ce9cdf29e7332c14acaca45200cd432a5767be38929ef8de43d0e1a5e7300c1eb669ac1ab997b31cb1403af8451e77e63505920af0f8c3abf5a9450ea47371039ba1cf2d65a14fa5f013b7ce1d175859404dcf6461a36e8bc260e7abf739d8951ddf1a3754e2d65e0aa31320a5ffca822023bc0906" ) == 0 );
15589  }
15590  }
15591  }
15592  FCT_TEST_END();
15593 
15594 
15595  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024120_2)
15596  {
15597  unsigned char key_str[128];
15598  unsigned char src_str[128];
15599  unsigned char dst_str[257];
15600  unsigned char iv_str[128];
15601  unsigned char add_str[128];
15602  unsigned char tag_str[128];
15603  unsigned char output[128];
15604  gcm_context ctx;
15605  unsigned int key_len;
15606  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
15607  int ret;
15608 
15609  memset(key_str, 0x00, 128);
15610  memset(src_str, 0x00, 128);
15611  memset(dst_str, 0x00, 257);
15612  memset(iv_str, 0x00, 128);
15613  memset(add_str, 0x00, 128);
15614  memset(tag_str, 0x00, 128);
15615  memset(output, 0x00, 128);
15616 
15617  key_len = unhexify( key_str, "fc46976d38a581a7042a94ea4b5bfe3587ddc65d1162d71e" );
15618  pt_len = unhexify( src_str, "4b9e858fc8f01903e426112192d4ae4686b1ae4d683b75afb2b8c63590275943d0d6d6a23b6d35796a2f101203acba107474ca6f4ff6dd87d6b77785ad1d160ef2755d84092dc70c86db5e639b689943b15efa646aff44b3f51f5d3f4cf6c8f7fc5adfe7bf2d72f75b93b8ee94ef3fa69ea0fc0bb77b3983901fdcd30bcd36f5" );
15619  iv_len = unhexify( iv_str, "b5e92563dd0339df00b7ffa2239d21bc" );
15620  add_len = unhexify( add_str, "7b6f6e104acbcd7188161477d8e425ff99add22df4d22de7f28d0a0075ca4ef848f68d07ed22d3165c08e40890ce04d1bd05b1a6ccb2fec8193d5f7dffc93d97a0c036b3748f708b011b68247a0249b9e1a60b652164e5c2fd7210377de804ac010c8aa08a11f40af97e8370a59f936cd14c22ea7a236d904145adc04a241fc0" );
15621  unhexify( tag_str, "d4356cb417953b01f7b1110c8aa3eb" );
15622 
15623  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15624  if( 0 == 0 )
15625  {
15626  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15627 
15628  if( strcmp( "FAIL", "FAIL" ) == 0 )
15629  {
15630  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15631  }
15632  else
15633  {
15634  hexify( dst_str, output, pt_len );
15635 
15636  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15637  }
15638  }
15639  }
15640  FCT_TEST_END();
15641 
15642 
15643  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024112_0)
15644  {
15645  unsigned char key_str[128];
15646  unsigned char src_str[128];
15647  unsigned char dst_str[257];
15648  unsigned char iv_str[128];
15649  unsigned char add_str[128];
15650  unsigned char tag_str[128];
15651  unsigned char output[128];
15652  gcm_context ctx;
15653  unsigned int key_len;
15654  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
15655  int ret;
15656 
15657  memset(key_str, 0x00, 128);
15658  memset(src_str, 0x00, 128);
15659  memset(dst_str, 0x00, 257);
15660  memset(iv_str, 0x00, 128);
15661  memset(add_str, 0x00, 128);
15662  memset(tag_str, 0x00, 128);
15663  memset(output, 0x00, 128);
15664 
15665  key_len = unhexify( key_str, "403e49feadd4db763652ed5c4b1e12680cfe0abc30f4696d" );
15666  pt_len = unhexify( src_str, "221c61d769febce3913bfead9a201a805f11005ddcac185cbae00ce749de9c4362889b1b0d9546e91598e0ddedb88b673a90acca65d7e71a85636be052f361839a646dc8b834c02f3e2261d370e6bac9636b7536225b5ea77881200c8a3450d21bfd1e11afb3a470e178ecfe944a25a7cd0254e04a42b67723aac8afffd56fee" );
15667  iv_len = unhexify( iv_str, "1a60258a56e15f92814b4d372255a80d" );
15668  add_len = unhexify( add_str, "a4ffa9e3c612103224c86515dad4343cbca7a7daf277f5828670834f4d9af67b9a935c71b2130dfbc929c4409bffb7974ffa87523b58890770439c33342880b33319c626bf776c1c0aeb9c2a348a7681572f4ff711d94c192f3450e8b1275f9d02c742a2c9f1da316e9918bf787f22699172986cb9b10fc56d5f6b8392ff92b8" );
15669  unhexify( tag_str, "62646fc8bfe38b3ba6d62f9011e3" );
15670 
15671  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15672  if( 0 == 0 )
15673  {
15674  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15675 
15676  if( strcmp( "FAIL", "5c76c90dea7d659804ad873960906259fbdda3614277ec575d9eec730e747a2e7b9df6716b4c38d3451e319eeecee74d1f4918266fc9239de87080f1ad437b47c6904ed2d5514161ad25e3e237655e00e53fe18d452576580e89b2f1f0f6aa7e40a337fd8c48d690fe013a67264a80e9b5dfd009a9152d559aa02a68f401a09b" ) == 0 )
15677  {
15678  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15679  }
15680  else
15681  {
15682  hexify( dst_str, output, pt_len );
15683 
15684  fct_chk( strcmp( (char *) dst_str, "5c76c90dea7d659804ad873960906259fbdda3614277ec575d9eec730e747a2e7b9df6716b4c38d3451e319eeecee74d1f4918266fc9239de87080f1ad437b47c6904ed2d5514161ad25e3e237655e00e53fe18d452576580e89b2f1f0f6aa7e40a337fd8c48d690fe013a67264a80e9b5dfd009a9152d559aa02a68f401a09b" ) == 0 );
15685  }
15686  }
15687  }
15688  FCT_TEST_END();
15689 
15690 
15691  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024112_1)
15692  {
15693  unsigned char key_str[128];
15694  unsigned char src_str[128];
15695  unsigned char dst_str[257];
15696  unsigned char iv_str[128];
15697  unsigned char add_str[128];
15698  unsigned char tag_str[128];
15699  unsigned char output[128];
15700  gcm_context ctx;
15701  unsigned int key_len;
15702  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
15703  int ret;
15704 
15705  memset(key_str, 0x00, 128);
15706  memset(src_str, 0x00, 128);
15707  memset(dst_str, 0x00, 257);
15708  memset(iv_str, 0x00, 128);
15709  memset(add_str, 0x00, 128);
15710  memset(tag_str, 0x00, 128);
15711  memset(output, 0x00, 128);
15712 
15713  key_len = unhexify( key_str, "c3471259512d1f03ce44c1ddac186e9a56c1434a6ac567c6" );
15714  pt_len = unhexify( src_str, "dd5b98b3b3cf03fb92be579068a885afd984630692eb5f155fa6b49f2b1690b803d34b90e8de3cc39c2e61650ffffb51e7ef36d35ad17dc4d91f336363b0734996b162b509c9954cab3dd959bde7e437e9100d84c44104c61e29dbe12492a0272ce6eea2906d390de7808d337e8c650b3301af04a9ed52ab9ea208f3c7439d6c" );
15715  iv_len = unhexify( iv_str, "50164c63d466148ab371376d5c2b6b72" );
15716  add_len = unhexify( add_str, "11d1f523888bea1fbc680d34bc9b66957d651efa59e788db3d3f6f50e72184b9d14e9ff9bc05fb687520cf423d681812e007025eedf0e78e7e8191e6b62404e8eb400cf837d762a31aa248553367263d6de091fcf7abedc3e69fc118b7efb0594c89b96c387b7c28ed9a7b75db60b6b5133949b891ff81eca5790a265f12a58c" );
15717  unhexify( tag_str, "6c5f38232e8a43871ab72a3419ad" );
15718 
15719  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15720  if( 0 == 0 )
15721  {
15722  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15723 
15724  if( strcmp( "FAIL", "50438ee712720abf2089331e4c058b30c30c3d17834c507c0010ac3f974a256d01b14a45e9ce5193c5cede41330cf31e1a07a1f5e3ceca515cc971bfda0fbe0b823450efc30563e8ed941b0350f146ec75cd31a2c7e1e469c2dd860c0fd5b286219018d4fbacda164a40d2980aa3a27aa95f8b8e2cd8e2f5f20d79a22c3ff028" ) == 0 )
15725  {
15726  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15727  }
15728  else
15729  {
15730  hexify( dst_str, output, pt_len );
15731 
15732  fct_chk( strcmp( (char *) dst_str, "50438ee712720abf2089331e4c058b30c30c3d17834c507c0010ac3f974a256d01b14a45e9ce5193c5cede41330cf31e1a07a1f5e3ceca515cc971bfda0fbe0b823450efc30563e8ed941b0350f146ec75cd31a2c7e1e469c2dd860c0fd5b286219018d4fbacda164a40d2980aa3a27aa95f8b8e2cd8e2f5f20d79a22c3ff028" ) == 0 );
15733  }
15734  }
15735  }
15736  FCT_TEST_END();
15737 
15738 
15739  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024112_2)
15740  {
15741  unsigned char key_str[128];
15742  unsigned char src_str[128];
15743  unsigned char dst_str[257];
15744  unsigned char iv_str[128];
15745  unsigned char add_str[128];
15746  unsigned char tag_str[128];
15747  unsigned char output[128];
15748  gcm_context ctx;
15749  unsigned int key_len;
15750  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
15751  int ret;
15752 
15753  memset(key_str, 0x00, 128);
15754  memset(src_str, 0x00, 128);
15755  memset(dst_str, 0x00, 257);
15756  memset(iv_str, 0x00, 128);
15757  memset(add_str, 0x00, 128);
15758  memset(tag_str, 0x00, 128);
15759  memset(output, 0x00, 128);
15760 
15761  key_len = unhexify( key_str, "ec326a1e0fe6a99421398df4fc7d8fea67b67e5f5fcd50ad" );
15762  pt_len = unhexify( src_str, "6d5016c434a0f4b4a5d9e0b6b8e2d848a94f132f055d2d847e54601a4c9cfc5966a654d696f8a3529a48a90b491ea0d31c08eae8ef364f71f8ec7ae7f7e39bb9c331137b2578362ff165628099944ba8deb0d99ac660d5ed2215b9a7626ff1fa6173cd8dd676c988d16c9cf750a0d793f584c3c8f5fd5d167bc278f4d77a629c" );
15763  iv_len = unhexify( iv_str, "c94aa4baa840a044dbd5942787a0c951" );
15764  add_len = unhexify( add_str, "f8401c578f20d9c250ea86eb945184e007a0190462c7abddf238ce1ceddcc230756aa222386d8ba66ebbba13de008ced140896ac55bc47c231cc81370ca9feadc225e017d59890e6291cc4cca27db3078c0cd6cbb51afb62210226a76837c5454728cb5ce3afe7352e7fe75421f94986e6b7b26321bbca15c75ac7c13dc15f50" );
15765  unhexify( tag_str, "3269922affb9d767f5abe041cc8e" );
15766 
15767  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15768  if( 0 == 0 )
15769  {
15770  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15771 
15772  if( strcmp( "FAIL", "FAIL" ) == 0 )
15773  {
15774  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15775  }
15776  else
15777  {
15778  hexify( dst_str, output, pt_len );
15779 
15780  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15781  }
15782  }
15783  }
15784  FCT_TEST_END();
15785 
15786 
15787  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024104_0)
15788  {
15789  unsigned char key_str[128];
15790  unsigned char src_str[128];
15791  unsigned char dst_str[257];
15792  unsigned char iv_str[128];
15793  unsigned char add_str[128];
15794  unsigned char tag_str[128];
15795  unsigned char output[128];
15796  gcm_context ctx;
15797  unsigned int key_len;
15798  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
15799  int ret;
15800 
15801  memset(key_str, 0x00, 128);
15802  memset(src_str, 0x00, 128);
15803  memset(dst_str, 0x00, 257);
15804  memset(iv_str, 0x00, 128);
15805  memset(add_str, 0x00, 128);
15806  memset(tag_str, 0x00, 128);
15807  memset(output, 0x00, 128);
15808 
15809  key_len = unhexify( key_str, "a7ef81652f604e88a72416924c53979dc73cadd3575eda1c" );
15810  pt_len = unhexify( src_str, "9ecd19a8eba9fba843486e1bbfb8d9053c5e04b24e30174d4aa89d8307439d653f8630edddafd51719c744bcb4bce3e444847567bd2cdde2995870d0634cc0ba2bde4b6bc2bc583062fb83874a1c25b50aeb945bd109a151772c077438c4d1caaeb5b0c56390ac23c6d117f3a00fd616306fc2ffc4c1e76f934b30fbbc52eec2" );
15811  iv_len = unhexify( iv_str, "0cc9ae54c9a85f3e9325c5f3658ab3b2" );
15812  add_len = unhexify( add_str, "d0195b744351aa25a57a99df9573dfa3cebe9850139149b64f7e4af37756a430dda8af98e4ed480e913aa82821c01c1f75b187e105a8f39621757d522c083a8d81d7d8bfe6cf15c439d0692b6affd655a11bcd2457046fae996a1075c66029867b88cd23c503ae04037dd41f27bafd5000d1f516002f9fcc0f2500e8c1b27de0" );
15813  unhexify( tag_str, "22c2efeddfd5d9cb528861c4eb" );
15814 
15815  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15816  if( 0 == 0 )
15817  {
15818  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15819 
15820  if( strcmp( "FAIL", "FAIL" ) == 0 )
15821  {
15822  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15823  }
15824  else
15825  {
15826  hexify( dst_str, output, pt_len );
15827 
15828  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15829  }
15830  }
15831  }
15832  FCT_TEST_END();
15833 
15834 
15835  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024104_1)
15836  {
15837  unsigned char key_str[128];
15838  unsigned char src_str[128];
15839  unsigned char dst_str[257];
15840  unsigned char iv_str[128];
15841  unsigned char add_str[128];
15842  unsigned char tag_str[128];
15843  unsigned char output[128];
15844  gcm_context ctx;
15845  unsigned int key_len;
15846  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
15847  int ret;
15848 
15849  memset(key_str, 0x00, 128);
15850  memset(src_str, 0x00, 128);
15851  memset(dst_str, 0x00, 257);
15852  memset(iv_str, 0x00, 128);
15853  memset(add_str, 0x00, 128);
15854  memset(tag_str, 0x00, 128);
15855  memset(output, 0x00, 128);
15856 
15857  key_len = unhexify( key_str, "605271a41e263c92dc14fe9df5203e79d58cc2d1289dc361" );
15858  pt_len = unhexify( src_str, "2bda3448a283ecba31e0299c0a9e44628cb2b41fa7b1a41107e107cabc381083bdbe048f2804568fdd5fe016f4d607f694042a459ba03a2deda4cccc8cbe4612d8ed0d4575e48bc9f59843369dbe2af6d048e65ff4250e1eef61d7b1b378fe2f3305b133ddc7e37d95ca6de89a971730fc80da943a767ff137707a8d8a24329c" );
15859  iv_len = unhexify( iv_str, "7f128092a777fc503adc7f6b85eb2006" );
15860  add_len = unhexify( add_str, "aef9f984fb645e08d5f0aa07a31c114d2f8e9eca047e4a8d5471378cfc2ced1159dc093d174788e58447a854be58942ed9a3fd45f3f4a1af7351e087369a267797c525f134e79709097e733b9003b9be0c569fc70ee3462b815b6410e19954ce2efac121300c06fd9e00542a9c6a5a682fe1010c145acbbb8b82333bdb5ddfd9" );
15861  unhexify( tag_str, "673afea592b2ce16bd058469f1" );
15862 
15863  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15864  if( 0 == 0 )
15865  {
15866  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15867 
15868  if( strcmp( "FAIL", "FAIL" ) == 0 )
15869  {
15870  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15871  }
15872  else
15873  {
15874  hexify( dst_str, output, pt_len );
15875 
15876  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15877  }
15878  }
15879  }
15880  FCT_TEST_END();
15881 
15882 
15883  FCT_TEST_BGN(gcm_nist_validation_aes_19212810241024104_2)
15884  {
15885  unsigned char key_str[128];
15886  unsigned char src_str[128];
15887  unsigned char dst_str[257];
15888  unsigned char iv_str[128];
15889  unsigned char add_str[128];
15890  unsigned char tag_str[128];
15891  unsigned char output[128];
15892  gcm_context ctx;
15893  unsigned int key_len;
15894  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
15895  int ret;
15896 
15897  memset(key_str, 0x00, 128);
15898  memset(src_str, 0x00, 128);
15899  memset(dst_str, 0x00, 257);
15900  memset(iv_str, 0x00, 128);
15901  memset(add_str, 0x00, 128);
15902  memset(tag_str, 0x00, 128);
15903  memset(output, 0x00, 128);
15904 
15905  key_len = unhexify( key_str, "fa076f36cb678e2275561e9553ebdf397360e5a5e44791c4" );
15906  pt_len = unhexify( src_str, "513305e86c0cb046c5d3720b25a406392766bd1fb7de2758de370ff2e68281e211922890c61f3659460f22c45a57895b424441262a3ba0606df4e2701f38281fd3436a4d0e0f8efecd231808a9ea063dfb725015a91f27cadfe7909a0ee109eac391ac807afed1767ae0515b9c1b51ae9a48b38fe7fec7fe0ddee562c945e5ae" );
15907  iv_len = unhexify( iv_str, "1ecd53d94fe287047ff184e8b9b71a26" );
15908  add_len = unhexify( add_str, "5ff25f7bac5f76f533f9edffdfd2b2991d7fc4cd5a0452a1031da6094cd498297fb2a05ae8db71cb3451e4ac33a01172619035a9621d2d54f812ef5343e14b9dedc93838e4cf30e223d215b4d2476ea961a17ac7295069f25b2a12d6e2efe76d91f45632c6d4e61ff19a95d5ae36af960d95050ce98b5791df0b7e322411c884" );
15909  unhexify( tag_str, "079e8db9c3e6eddb0335b1cf64" );
15910 
15911  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15912  if( 0 == 0 )
15913  {
15914  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15915 
15916  if( strcmp( "FAIL", "FAIL" ) == 0 )
15917  {
15918  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15919  }
15920  else
15921  {
15922  hexify( dst_str, output, pt_len );
15923 
15924  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
15925  }
15926  }
15927  }
15928  FCT_TEST_END();
15929 
15930 
15931  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102496_0)
15932  {
15933  unsigned char key_str[128];
15934  unsigned char src_str[128];
15935  unsigned char dst_str[257];
15936  unsigned char iv_str[128];
15937  unsigned char add_str[128];
15938  unsigned char tag_str[128];
15939  unsigned char output[128];
15940  gcm_context ctx;
15941  unsigned int key_len;
15942  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
15943  int ret;
15944 
15945  memset(key_str, 0x00, 128);
15946  memset(src_str, 0x00, 128);
15947  memset(dst_str, 0x00, 257);
15948  memset(iv_str, 0x00, 128);
15949  memset(add_str, 0x00, 128);
15950  memset(tag_str, 0x00, 128);
15951  memset(output, 0x00, 128);
15952 
15953  key_len = unhexify( key_str, "ce9dafa0e7e53a8766fc0bc38fba807d04e14e5ed61bc234" );
15954  pt_len = unhexify( src_str, "b585b8bf634757dac015f2f69f2ae674372a664f2115ad2d03bd3e0c335306b02d0947d3cda5991f5c0c25f12ead2c3cc2d65d575fd67091c70bc93ddb4b1e21f7b0fc6e6ae652dea93a6564ff13489f927942e64dd94bf8f821c7ffdef16df58bd8306a957821ac256da6f19c9d96e48eee87f88acb83bae05d693b70b9337b" );
15955  iv_len = unhexify( iv_str, "fd0751af49814ee98b2b0cdf730adaa6" );
15956  add_len = unhexify( add_str, "1cba488a0fc8a012f9a336cc7b01cbcc504178eeb08237dbedbc6c7ac68fdf3a6742751a207e43d43068abf6ef4e12a5e3c17e5a2f9398fc04ced67377cbb858fd6020fad675a880adb249e4aba94b96efa515d1cdf5c0c3071a27a3245968867ea94b2bfc2028a67be34c84c3f475944497aa8ca1ab009f8e4b11c8308c1996" );
15957  unhexify( tag_str, "e5dc92f4ad4000e9b62fb637" );
15958 
15959  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
15960  if( 0 == 0 )
15961  {
15962  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
15963 
15964  if( strcmp( "FAIL", "95f4324b0656bef19eca5570548fc6a7a9923f4e2a7e42066891bc132fd73bc1c9089755d996756de0072824e69c43f2db8ba2bf6f90d3c4eafc0721ceaccce1af896f9fb15fb19c4746979b6d945f593fad61d550f81d12b5945ed728c02931d7f8d917285c22a3af748d75a6bf163fddd84b941d8564c1a63192c816ad6d6d" ) == 0 )
15965  {
15966  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
15967  }
15968  else
15969  {
15970  hexify( dst_str, output, pt_len );
15971 
15972  fct_chk( strcmp( (char *) dst_str, "95f4324b0656bef19eca5570548fc6a7a9923f4e2a7e42066891bc132fd73bc1c9089755d996756de0072824e69c43f2db8ba2bf6f90d3c4eafc0721ceaccce1af896f9fb15fb19c4746979b6d945f593fad61d550f81d12b5945ed728c02931d7f8d917285c22a3af748d75a6bf163fddd84b941d8564c1a63192c816ad6d6d" ) == 0 );
15973  }
15974  }
15975  }
15976  FCT_TEST_END();
15977 
15978 
15979  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102496_1)
15980  {
15981  unsigned char key_str[128];
15982  unsigned char src_str[128];
15983  unsigned char dst_str[257];
15984  unsigned char iv_str[128];
15985  unsigned char add_str[128];
15986  unsigned char tag_str[128];
15987  unsigned char output[128];
15988  gcm_context ctx;
15989  unsigned int key_len;
15990  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
15991  int ret;
15992 
15993  memset(key_str, 0x00, 128);
15994  memset(src_str, 0x00, 128);
15995  memset(dst_str, 0x00, 257);
15996  memset(iv_str, 0x00, 128);
15997  memset(add_str, 0x00, 128);
15998  memset(tag_str, 0x00, 128);
15999  memset(output, 0x00, 128);
16000 
16001  key_len = unhexify( key_str, "8a328554fed68dc4838fbc89fd162c99ec105b36651abbc9" );
16002  pt_len = unhexify( src_str, "75986f56972c045c850ed68aeb229f203b228fdfc36cad6b16d9bd12037c48700d20d8062a983ffeca76b8d36a67ef51bc8853706e83a34e4e23ff4f4a4eb943f19dbe85e454043d7906be6587a85079f9ccd27962d2905117d2dbeaf725d6ffe87bef52b2138da153ef29b18065b3342b3f9d07837d57b8bc5f2597de06c54f" );
16003  iv_len = unhexify( iv_str, "e4f7c69a1d026eeebfc45e77bd7b3538" );
16004  add_len = unhexify( add_str, "e349dcedb0bfcc771c820f0d510b80cef32ae3326484e25aa183015941e7844bc46f617d5e61fd64fa71759e90fcb72ae220bcd507f0fb389b689dd3fa29b3b937eded85f26ada9e0f3f5109f82fef47c7eba7313049750ad17969e7550c0d4093ed18ee27843d082bcee8bf3fc7833d569b7723998595a5a1d871089fd238da" );
16005  unhexify( tag_str, "8e8320912fff628f47e92430" );
16006 
16007  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16008  if( 0 == 0 )
16009  {
16010  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16011 
16012  if( strcmp( "FAIL", "a1ed65cfc7e1aeccd0531bce1dc749c7aa84451ec0f29856f12f22c4105888c7d62e2e2fc8ad7a62748610b16e57490f061ad063c88800037d7244ee59e109d445205280473390336d7b6089f3a78218447b1b2398c4d0b3aac8b57a35891ad60dc1b69ad75e2e86248ceac7bb4cf3caade4a896e5ee8c76893ef990f6f65266" ) == 0 )
16013  {
16014  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16015  }
16016  else
16017  {
16018  hexify( dst_str, output, pt_len );
16019 
16020  fct_chk( strcmp( (char *) dst_str, "a1ed65cfc7e1aeccd0531bce1dc749c7aa84451ec0f29856f12f22c4105888c7d62e2e2fc8ad7a62748610b16e57490f061ad063c88800037d7244ee59e109d445205280473390336d7b6089f3a78218447b1b2398c4d0b3aac8b57a35891ad60dc1b69ad75e2e86248ceac7bb4cf3caade4a896e5ee8c76893ef990f6f65266" ) == 0 );
16021  }
16022  }
16023  }
16024  FCT_TEST_END();
16025 
16026 
16027  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102496_2)
16028  {
16029  unsigned char key_str[128];
16030  unsigned char src_str[128];
16031  unsigned char dst_str[257];
16032  unsigned char iv_str[128];
16033  unsigned char add_str[128];
16034  unsigned char tag_str[128];
16035  unsigned char output[128];
16036  gcm_context ctx;
16037  unsigned int key_len;
16038  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
16039  int ret;
16040 
16041  memset(key_str, 0x00, 128);
16042  memset(src_str, 0x00, 128);
16043  memset(dst_str, 0x00, 257);
16044  memset(iv_str, 0x00, 128);
16045  memset(add_str, 0x00, 128);
16046  memset(tag_str, 0x00, 128);
16047  memset(output, 0x00, 128);
16048 
16049  key_len = unhexify( key_str, "6e7f6feb4022312de5c804ed1d7a37580d74499107f8cc8b" );
16050  pt_len = unhexify( src_str, "4f5bbdf575ab8f778549f749f2265e17dc7225713e73ee6d7be163ff7071557dcc2240b0705c079008605f81396414ac64f06b1b637876e04c3fca8d0fa576cef4dd3dc553fd6808eaf120f837f9bb1d9dbbd5cf67ed497167fc7db89d3a84151b81aeab0e921057f121583df5ed7f976b206ece17a913f23485385f64c462a8" );
16051  iv_len = unhexify( iv_str, "6ce13485ffbc80567b02dd542344d7ef" );
16052  add_len = unhexify( add_str, "c6804a2bd8c34de14fe485c8b7caa2564adaf9fcbb754bd2cc1d88ba9183f13d110c762a3c5d2afc0fbc80aedcb91e45efe43d9320075420ee85ab22505f20e77fa4624b0387346c1bd944e9cd54055b5135c7fc92e85390ecf45a7091136b47e3d68d9076594cfad36c36047538e652178c375a2fe59a246a79784577860189" );
16053  unhexify( tag_str, "974bd0c4a8cac1563a0e0ce0" );
16054 
16055  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16056  if( 0 == 0 )
16057  {
16058  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16059 
16060  if( strcmp( "FAIL", "FAIL" ) == 0 )
16061  {
16062  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16063  }
16064  else
16065  {
16066  hexify( dst_str, output, pt_len );
16067 
16068  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16069  }
16070  }
16071  }
16072  FCT_TEST_END();
16073 
16074 
16075  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102464_0)
16076  {
16077  unsigned char key_str[128];
16078  unsigned char src_str[128];
16079  unsigned char dst_str[257];
16080  unsigned char iv_str[128];
16081  unsigned char add_str[128];
16082  unsigned char tag_str[128];
16083  unsigned char output[128];
16084  gcm_context ctx;
16085  unsigned int key_len;
16086  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
16087  int ret;
16088 
16089  memset(key_str, 0x00, 128);
16090  memset(src_str, 0x00, 128);
16091  memset(dst_str, 0x00, 257);
16092  memset(iv_str, 0x00, 128);
16093  memset(add_str, 0x00, 128);
16094  memset(tag_str, 0x00, 128);
16095  memset(output, 0x00, 128);
16096 
16097  key_len = unhexify( key_str, "46d6e982feff0e7d04a84384c56739b69626dde500e4b7fb" );
16098  pt_len = unhexify( src_str, "a5160fb2d397b55a7eba02df33a042404188f02f4492d46f4edc03fc67723d64f5f7fed3a60728438703c60454a30f473ac918ffc8f98be5c5e9779ee984415e415ce3c71f9acc3f808d215be58535d3144cebe7982b9b527edbe41446161094d6fc74dec2e0a1c644bbc2cf5779a22bd4117a7edb11d13e35e95feeb418d3f0" );
16099  iv_len = unhexify( iv_str, "71a6d1e022a6bdff6460c674fb0cf048" );
16100  add_len = unhexify( add_str, "67a8455c7d3fbfdba3c5ec5f40e0be935fbb9417e805771832ffad06ba38a61b8377997af1f586dc0fa1e3da0b39facd520db1f0ec2bdf1904a3a897f0b507c901fab30a85de51effa9f7d4703ceeb2ca72abe0bd146ba0bd3ffdee11628310db7d65ea1343b018084ea2414995f86fefb45ba91a9dc2236d92078b4305671b5" );
16101  unhexify( tag_str, "84f1efd34ff84e83" );
16102 
16103  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16104  if( 0 == 0 )
16105  {
16106  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16107 
16108  if( strcmp( "FAIL", "FAIL" ) == 0 )
16109  {
16110  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16111  }
16112  else
16113  {
16114  hexify( dst_str, output, pt_len );
16115 
16116  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16117  }
16118  }
16119  }
16120  FCT_TEST_END();
16121 
16122 
16123  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102464_1)
16124  {
16125  unsigned char key_str[128];
16126  unsigned char src_str[128];
16127  unsigned char dst_str[257];
16128  unsigned char iv_str[128];
16129  unsigned char add_str[128];
16130  unsigned char tag_str[128];
16131  unsigned char output[128];
16132  gcm_context ctx;
16133  unsigned int key_len;
16134  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
16135  int ret;
16136 
16137  memset(key_str, 0x00, 128);
16138  memset(src_str, 0x00, 128);
16139  memset(dst_str, 0x00, 257);
16140  memset(iv_str, 0x00, 128);
16141  memset(add_str, 0x00, 128);
16142  memset(tag_str, 0x00, 128);
16143  memset(output, 0x00, 128);
16144 
16145  key_len = unhexify( key_str, "991dcaa2e8fdad2b4e6e462a3c06c96067ef5e9fb133496a" );
16146  pt_len = unhexify( src_str, "9cd0c27f0c2011c1ab947400d28516c7f46d22a409a18fd35c1babf693b8030dfd7822d9ba03bb8fd56a00f9c7149c056640dde690889d2f23978eeeb28ccc26e2fc251220a3682c963f5580c654c1a6736cccb1b8ed104ec7390021d244bd9f92abde89e39a4b83eff8211c8a6259bd6ac2af1da7dfb8cf1355238056c60381" );
16147  iv_len = unhexify( iv_str, "978913d2c822ba7cc758041d5ee46759" );
16148  add_len = unhexify( add_str, "5a94dc81af011a8af263318b60215b9752292b194b89f6fc013b0fe8e29133de631d981862f2c131ee34905bd93caffc3b8f91aeb0264b27a509e5c6a41ae781209f8c5895d0d35b3c5e1ae34a1a92a2b979e0e62132051394940ea4d9bfffb8d89ba1e8331b15bdf05c41db83a57745a4a651a757cc8648acdcf850a2f25367" );
16149  unhexify( tag_str, "15d456da7645abf2" );
16150 
16151  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16152  if( 0 == 0 )
16153  {
16154  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16155 
16156  if( strcmp( "FAIL", "FAIL" ) == 0 )
16157  {
16158  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16159  }
16160  else
16161  {
16162  hexify( dst_str, output, pt_len );
16163 
16164  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16165  }
16166  }
16167  }
16168  FCT_TEST_END();
16169 
16170 
16171  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102464_2)
16172  {
16173  unsigned char key_str[128];
16174  unsigned char src_str[128];
16175  unsigned char dst_str[257];
16176  unsigned char iv_str[128];
16177  unsigned char add_str[128];
16178  unsigned char tag_str[128];
16179  unsigned char output[128];
16180  gcm_context ctx;
16181  unsigned int key_len;
16182  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
16183  int ret;
16184 
16185  memset(key_str, 0x00, 128);
16186  memset(src_str, 0x00, 128);
16187  memset(dst_str, 0x00, 257);
16188  memset(iv_str, 0x00, 128);
16189  memset(add_str, 0x00, 128);
16190  memset(tag_str, 0x00, 128);
16191  memset(output, 0x00, 128);
16192 
16193  key_len = unhexify( key_str, "f29cff00781f5916930f125489c87d21f6593324d1506f65" );
16194  pt_len = unhexify( src_str, "a3e8595747b7147d471ac4fe38014bf4a409931e3f419ff88ae249ba7a7f51bd0ede371bf153bab4b28020b7a82a8ca30b75f1e3bcfee3c13db813cbc85138ef05874dedb14a6e5b6d06d7589a83bd5e052dc64433a8e24c1188b9470ddb2536d13b4b7bff0c5afcfaa9aa0157c3aae3b1774df2df14f965d6dee4332edba67e" );
16195  iv_len = unhexify( iv_str, "50db7ee25a9f815c784236f908bfd7f2" );
16196  add_len = unhexify( add_str, "ec1482e18692bcd6894a364c4a6abb9c3b9818bb17e5e1fc9ec0b41702c423f3a60907e94c888fad8e78f51e1f724b39969ba7b11d31b503504b304d5c4b4cbd42634f4ec5080a9fe51c82e121ae191270dd2c307af84c82d892d982413a50ccce33698054f761a3fa93da9a1fca321296b378a50d458ba78e57a70da4676150" );
16197  unhexify( tag_str, "a1e19ef2f0d4b9f1" );
16198 
16199  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16200  if( 0 == 0 )
16201  {
16202  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16203 
16204  if( strcmp( "FAIL", "eea18261a4de31d8619e77005ebbb3998c5dcfac2bc120ae465e29d6b4c46de7e6c044c8b148ffe4eda7629c243df8af4e7ceb512d5751a3ee58defb0690b6f26b51086dedfde38748f6f0bbe6b495f4304373188e5d2dc93461bd51bf720149a7d3aa543623b122b9af0123b2cdc9020136b041a49498ec4aa696c2d3c46d06" ) == 0 )
16205  {
16206  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16207  }
16208  else
16209  {
16210  hexify( dst_str, output, pt_len );
16211 
16212  fct_chk( strcmp( (char *) dst_str, "eea18261a4de31d8619e77005ebbb3998c5dcfac2bc120ae465e29d6b4c46de7e6c044c8b148ffe4eda7629c243df8af4e7ceb512d5751a3ee58defb0690b6f26b51086dedfde38748f6f0bbe6b495f4304373188e5d2dc93461bd51bf720149a7d3aa543623b122b9af0123b2cdc9020136b041a49498ec4aa696c2d3c46d06" ) == 0 );
16213  }
16214  }
16215  }
16216  FCT_TEST_END();
16217 
16218 
16219  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102432_0)
16220  {
16221  unsigned char key_str[128];
16222  unsigned char src_str[128];
16223  unsigned char dst_str[257];
16224  unsigned char iv_str[128];
16225  unsigned char add_str[128];
16226  unsigned char tag_str[128];
16227  unsigned char output[128];
16228  gcm_context ctx;
16229  unsigned int key_len;
16230  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
16231  int ret;
16232 
16233  memset(key_str, 0x00, 128);
16234  memset(src_str, 0x00, 128);
16235  memset(dst_str, 0x00, 257);
16236  memset(iv_str, 0x00, 128);
16237  memset(add_str, 0x00, 128);
16238  memset(tag_str, 0x00, 128);
16239  memset(output, 0x00, 128);
16240 
16241  key_len = unhexify( key_str, "2087e14092dad6df8996715cb1cfca90094f030328080ffd" );
16242  pt_len = unhexify( src_str, "6d039513061980fb195bdf2f7c7079ca4b7e0fdd50d948cbfab5ba10b99e3aea27f08abd000c428851de82cacb0d64c146cd9567e9d55b89819876d6a635bd68bcaf47ffa41e02d9ee97f5a2363bfe6131ae7a21ea5130ae953a64d57d6cbfd45260c5f1946388d445ce97d23ab7ba31a5069a4896bc940a71de32bde02bc18d" );
16243  iv_len = unhexify( iv_str, "d30504afb6f8b6ac444b4a76115d79d1" );
16244  add_len = unhexify( add_str, "d95845d268c8d8f9135d310c39e30f55f83ef7ffee69e6ba1f80d08e92ed473b5ac12cc8f7a872bfc8b325e6b8e374609c90beaf52d975f71caeef5ee4c13de08dce80d358ee1cd091faea209a24e3392adcfe01aeb2b2e1738bc75d4a9b7cd31df7f878141cf278d150f6faa83fb3a2fd1225542a39c900606c602f15c06a4f" );
16245  unhexify( tag_str, "5412f25c" );
16246 
16247  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16248  if( 0 == 0 )
16249  {
16250  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16251 
16252  if( strcmp( "FAIL", "1e81a4c10a3440d0002ddc1bfa42ebb08e504fcc8f0497915c51b6f5f75fee3f0cd3e9c5a81ff6528e0fecd68a36192114f17fa1a4cfe21918dac46e3ba1383c2678c7a6889a980024ee2a21bcf737f7723b5735e1ebe78996f7c7eace2802ebb8284216867d73b53a370a57d5b587d070a96db34b5b4f5afe7f39830498c112" ) == 0 )
16253  {
16254  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16255  }
16256  else
16257  {
16258  hexify( dst_str, output, pt_len );
16259 
16260  fct_chk( strcmp( (char *) dst_str, "1e81a4c10a3440d0002ddc1bfa42ebb08e504fcc8f0497915c51b6f5f75fee3f0cd3e9c5a81ff6528e0fecd68a36192114f17fa1a4cfe21918dac46e3ba1383c2678c7a6889a980024ee2a21bcf737f7723b5735e1ebe78996f7c7eace2802ebb8284216867d73b53a370a57d5b587d070a96db34b5b4f5afe7f39830498c112" ) == 0 );
16261  }
16262  }
16263  }
16264  FCT_TEST_END();
16265 
16266 
16267  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102432_1)
16268  {
16269  unsigned char key_str[128];
16270  unsigned char src_str[128];
16271  unsigned char dst_str[257];
16272  unsigned char iv_str[128];
16273  unsigned char add_str[128];
16274  unsigned char tag_str[128];
16275  unsigned char output[128];
16276  gcm_context ctx;
16277  unsigned int key_len;
16278  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
16279  int ret;
16280 
16281  memset(key_str, 0x00, 128);
16282  memset(src_str, 0x00, 128);
16283  memset(dst_str, 0x00, 257);
16284  memset(iv_str, 0x00, 128);
16285  memset(add_str, 0x00, 128);
16286  memset(tag_str, 0x00, 128);
16287  memset(output, 0x00, 128);
16288 
16289  key_len = unhexify( key_str, "3fc76d627c775de2f789279dc7b67979a9f1cc23c8dcabc9" );
16290  pt_len = unhexify( src_str, "92a60d38fc687b92d44635aafee416a142d11a025680e5aa42e9ba5aa010462991ad3dd7328ca4a693673410f9bba37f05a551b949ab0d43fc61ef3b8996dd3fc1b325e66eec6cc61ea667500f82a83e699756a139d14be6ca9747ed38cd9b1d9da032ece311331bdcd698666ddc970b8be2b746ec55fe60e65d7ae47c6f853c" );
16291  iv_len = unhexify( iv_str, "8f6fd53eb97e12dcd4d40f2843e25365" );
16292  add_len = unhexify( add_str, "e56995df73e52606a11de9df6c7bfb0ef93b86bf6766e319aea59372060294b0e1b13c6288c2310a4bef725a2dddb174f3e1228649861757903c4497a0eec9c141454fc75f101439a2150e368857c4f0f6e5161c42c77f632bf1c229a52595cbf16e9018de9a8f6a1e6b8b18bd244f93f001eb2eb315405d223c0d27ece9d4d9" );
16293  unhexify( tag_str, "613ba486" );
16294 
16295  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16296  if( 0 == 0 )
16297  {
16298  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16299 
16300  if( strcmp( "FAIL", "FAIL" ) == 0 )
16301  {
16302  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16303  }
16304  else
16305  {
16306  hexify( dst_str, output, pt_len );
16307 
16308  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16309  }
16310  }
16311  }
16312  FCT_TEST_END();
16313 
16314 
16315  FCT_TEST_BGN(gcm_nist_validation_aes_1921281024102432_2)
16316  {
16317  unsigned char key_str[128];
16318  unsigned char src_str[128];
16319  unsigned char dst_str[257];
16320  unsigned char iv_str[128];
16321  unsigned char add_str[128];
16322  unsigned char tag_str[128];
16323  unsigned char output[128];
16324  gcm_context ctx;
16325  unsigned int key_len;
16326  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
16327  int ret;
16328 
16329  memset(key_str, 0x00, 128);
16330  memset(src_str, 0x00, 128);
16331  memset(dst_str, 0x00, 257);
16332  memset(iv_str, 0x00, 128);
16333  memset(add_str, 0x00, 128);
16334  memset(tag_str, 0x00, 128);
16335  memset(output, 0x00, 128);
16336 
16337  key_len = unhexify( key_str, "b10979797fb8f418a126120d45106e1779b4538751a19bf6" );
16338  pt_len = unhexify( src_str, "e3dc64e3c02731fe6e6ec0e899183018da347bf8bd476aa7746d7a7729d83a95f64bb732ba987468d0cede154e28169f7bafa36559200795037ee38279e0e4ca40f9cfa85aa0c8035df9649345c8fdffd1c31528b485dfe443c1923180cc8fae5196d16f822be4ad07e3f1234e1d218e7c8fb37a0e4480dc6717c9c09ff5c45f" );
16339  iv_len = unhexify( iv_str, "ca362e615024a1fe11286668646cc1de" );
16340  add_len = unhexify( add_str, "237d95d86a5ad46035870f576a1757eded636c7234d5ed0f8039f6f59f1333cc31cb893170d1baa98bd4e79576de920120ead0fdecfb343edbc2fcc556540a91607388a05d43bdb8b55f1327552feed3b620614dfcccb2b342083896cbc81dc9670b761add998913ca813163708a45974e6d7b56dfd0511a72eb879f239d6a6d" );
16341  unhexify( tag_str, "28d730ea" );
16342 
16343  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16344  if( 0 == 0 )
16345  {
16346  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16347 
16348  if( strcmp( "FAIL", "dafde27aa8b3076bfa16ab1d89207d339c4997f8a756cc3eb62c0b023976de808ab640ba4467f2b2ea83d238861229c73387594cd43770386512ea595a70888b4c38863472279e06b923e7cf32438199b3e054ac4bc21baa8df39ddaa207ebb17fa4cad6e83ea58c3a92ec74e6e01b0a8979af145dd31d5df29750bb91b42d45" ) == 0 )
16349  {
16350  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16351  }
16352  else
16353  {
16354  hexify( dst_str, output, pt_len );
16355 
16356  fct_chk( strcmp( (char *) dst_str, "dafde27aa8b3076bfa16ab1d89207d339c4997f8a756cc3eb62c0b023976de808ab640ba4467f2b2ea83d238861229c73387594cd43770386512ea595a70888b4c38863472279e06b923e7cf32438199b3e054ac4bc21baa8df39ddaa207ebb17fa4cad6e83ea58c3a92ec74e6e01b0a8979af145dd31d5df29750bb91b42d45" ) == 0 );
16357  }
16358  }
16359  }
16360  FCT_TEST_END();
16361 
16362 
16363  FCT_TEST_BGN(gcm_nist_validation_aes_25612800128_0)
16364  {
16365  unsigned char key_str[128];
16366  unsigned char src_str[128];
16367  unsigned char dst_str[257];
16368  unsigned char iv_str[128];
16369  unsigned char add_str[128];
16370  unsigned char tag_str[128];
16371  unsigned char output[128];
16372  gcm_context ctx;
16373  unsigned int key_len;
16374  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
16375  int ret;
16376 
16377  memset(key_str, 0x00, 128);
16378  memset(src_str, 0x00, 128);
16379  memset(dst_str, 0x00, 257);
16380  memset(iv_str, 0x00, 128);
16381  memset(add_str, 0x00, 128);
16382  memset(tag_str, 0x00, 128);
16383  memset(output, 0x00, 128);
16384 
16385  key_len = unhexify( key_str, "2c186654406b2b92c9639a7189d4ab5ab0b9bb87c43005027f3fa832fd3507b1" );
16386  pt_len = unhexify( src_str, "" );
16387  iv_len = unhexify( iv_str, "3a0324d63a70400490c92e7604a3ba97" );
16388  add_len = unhexify( add_str, "" );
16389  unhexify( tag_str, "4c61cd2e28a13d78a4e87ea7374dd01a" );
16390 
16391  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16392  if( 0 == 0 )
16393  {
16394  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16395 
16396  if( strcmp( "FAIL", "FAIL" ) == 0 )
16397  {
16398  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16399  }
16400  else
16401  {
16402  hexify( dst_str, output, pt_len );
16403 
16404  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16405  }
16406  }
16407  }
16408  FCT_TEST_END();
16409 
16410 
16411  FCT_TEST_BGN(gcm_nist_validation_aes_25612800128_1)
16412  {
16413  unsigned char key_str[128];
16414  unsigned char src_str[128];
16415  unsigned char dst_str[257];
16416  unsigned char iv_str[128];
16417  unsigned char add_str[128];
16418  unsigned char tag_str[128];
16419  unsigned char output[128];
16420  gcm_context ctx;
16421  unsigned int key_len;
16422  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
16423  int ret;
16424 
16425  memset(key_str, 0x00, 128);
16426  memset(src_str, 0x00, 128);
16427  memset(dst_str, 0x00, 257);
16428  memset(iv_str, 0x00, 128);
16429  memset(add_str, 0x00, 128);
16430  memset(tag_str, 0x00, 128);
16431  memset(output, 0x00, 128);
16432 
16433  key_len = unhexify( key_str, "747d01d82d7382b4263e7cbf25bd198a8a92faabf8d7367584c7e2fa506e9c5f" );
16434  pt_len = unhexify( src_str, "" );
16435  iv_len = unhexify( iv_str, "7156358b203a44ef173706fdc81900f8" );
16436  add_len = unhexify( add_str, "" );
16437  unhexify( tag_str, "9687fb231c4742a74d6bf78c62b8ac53" );
16438 
16439  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16440  if( 0 == 0 )
16441  {
16442  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16443 
16444  if( strcmp( "FAIL", "" ) == 0 )
16445  {
16446  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16447  }
16448  else
16449  {
16450  hexify( dst_str, output, pt_len );
16451 
16452  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
16453  }
16454  }
16455  }
16456  FCT_TEST_END();
16457 
16458 
16459  FCT_TEST_BGN(gcm_nist_validation_aes_25612800128_2)
16460  {
16461  unsigned char key_str[128];
16462  unsigned char src_str[128];
16463  unsigned char dst_str[257];
16464  unsigned char iv_str[128];
16465  unsigned char add_str[128];
16466  unsigned char tag_str[128];
16467  unsigned char output[128];
16468  gcm_context ctx;
16469  unsigned int key_len;
16470  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
16471  int ret;
16472 
16473  memset(key_str, 0x00, 128);
16474  memset(src_str, 0x00, 128);
16475  memset(dst_str, 0x00, 257);
16476  memset(iv_str, 0x00, 128);
16477  memset(add_str, 0x00, 128);
16478  memset(tag_str, 0x00, 128);
16479  memset(output, 0x00, 128);
16480 
16481  key_len = unhexify( key_str, "1cbe30216136b7eaf223e6a7b46c06625176d9a08182fa806a63d8b143aa768b" );
16482  pt_len = unhexify( src_str, "" );
16483  iv_len = unhexify( iv_str, "4fe6ace582c4e26ce71ee7f756fb7a88" );
16484  add_len = unhexify( add_str, "" );
16485  unhexify( tag_str, "d5bdf8ec2896acafb7022708d74646c7" );
16486 
16487  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16488  if( 0 == 0 )
16489  {
16490  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16491 
16492  if( strcmp( "FAIL", "" ) == 0 )
16493  {
16494  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16495  }
16496  else
16497  {
16498  hexify( dst_str, output, pt_len );
16499 
16500  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
16501  }
16502  }
16503  }
16504  FCT_TEST_END();
16505 
16506 
16507  FCT_TEST_BGN(gcm_nist_validation_aes_25612800120_0)
16508  {
16509  unsigned char key_str[128];
16510  unsigned char src_str[128];
16511  unsigned char dst_str[257];
16512  unsigned char iv_str[128];
16513  unsigned char add_str[128];
16514  unsigned char tag_str[128];
16515  unsigned char output[128];
16516  gcm_context ctx;
16517  unsigned int key_len;
16518  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
16519  int ret;
16520 
16521  memset(key_str, 0x00, 128);
16522  memset(src_str, 0x00, 128);
16523  memset(dst_str, 0x00, 257);
16524  memset(iv_str, 0x00, 128);
16525  memset(add_str, 0x00, 128);
16526  memset(tag_str, 0x00, 128);
16527  memset(output, 0x00, 128);
16528 
16529  key_len = unhexify( key_str, "f31194c83bb8da979a1eabb3337ceb3d38a663790da74380d8f94142ab8b8797" );
16530  pt_len = unhexify( src_str, "" );
16531  iv_len = unhexify( iv_str, "404efd26b665c97ea75437892cf676b6" );
16532  add_len = unhexify( add_str, "" );
16533  unhexify( tag_str, "e491075851eec28c723159cc1b2c76" );
16534 
16535  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16536  if( 0 == 0 )
16537  {
16538  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16539 
16540  if( strcmp( "FAIL", "" ) == 0 )
16541  {
16542  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16543  }
16544  else
16545  {
16546  hexify( dst_str, output, pt_len );
16547 
16548  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
16549  }
16550  }
16551  }
16552  FCT_TEST_END();
16553 
16554 
16555  FCT_TEST_BGN(gcm_nist_validation_aes_25612800120_1)
16556  {
16557  unsigned char key_str[128];
16558  unsigned char src_str[128];
16559  unsigned char dst_str[257];
16560  unsigned char iv_str[128];
16561  unsigned char add_str[128];
16562  unsigned char tag_str[128];
16563  unsigned char output[128];
16564  gcm_context ctx;
16565  unsigned int key_len;
16566  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
16567  int ret;
16568 
16569  memset(key_str, 0x00, 128);
16570  memset(src_str, 0x00, 128);
16571  memset(dst_str, 0x00, 257);
16572  memset(iv_str, 0x00, 128);
16573  memset(add_str, 0x00, 128);
16574  memset(tag_str, 0x00, 128);
16575  memset(output, 0x00, 128);
16576 
16577  key_len = unhexify( key_str, "daeed52ae4bf5cbe1ad58ae4ccb3da81fb9c0b6f7619ca21979313ad9d3e83c1" );
16578  pt_len = unhexify( src_str, "" );
16579  iv_len = unhexify( iv_str, "4037eadb11249884b6b38b5525ba2df4" );
16580  add_len = unhexify( add_str, "" );
16581  unhexify( tag_str, "360c6ef41cbd9cd4a4e649712d2930" );
16582 
16583  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16584  if( 0 == 0 )
16585  {
16586  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16587 
16588  if( strcmp( "FAIL", "" ) == 0 )
16589  {
16590  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16591  }
16592  else
16593  {
16594  hexify( dst_str, output, pt_len );
16595 
16596  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
16597  }
16598  }
16599  }
16600  FCT_TEST_END();
16601 
16602 
16603  FCT_TEST_BGN(gcm_nist_validation_aes_25612800120_2)
16604  {
16605  unsigned char key_str[128];
16606  unsigned char src_str[128];
16607  unsigned char dst_str[257];
16608  unsigned char iv_str[128];
16609  unsigned char add_str[128];
16610  unsigned char tag_str[128];
16611  unsigned char output[128];
16612  gcm_context ctx;
16613  unsigned int key_len;
16614  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
16615  int ret;
16616 
16617  memset(key_str, 0x00, 128);
16618  memset(src_str, 0x00, 128);
16619  memset(dst_str, 0x00, 257);
16620  memset(iv_str, 0x00, 128);
16621  memset(add_str, 0x00, 128);
16622  memset(tag_str, 0x00, 128);
16623  memset(output, 0x00, 128);
16624 
16625  key_len = unhexify( key_str, "3ad81c34389406a965c60edb3214663ac4a6bd5cfd154ae8d9dc86dae93def64" );
16626  pt_len = unhexify( src_str, "" );
16627  iv_len = unhexify( iv_str, "cebbce06a88852d3bb2978dbe2b5995a" );
16628  add_len = unhexify( add_str, "" );
16629  unhexify( tag_str, "bd7ca9f6bd1099cde87c0f0d7cc887" );
16630 
16631  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16632  if( 0 == 0 )
16633  {
16634  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16635 
16636  if( strcmp( "FAIL", "" ) == 0 )
16637  {
16638  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16639  }
16640  else
16641  {
16642  hexify( dst_str, output, pt_len );
16643 
16644  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
16645  }
16646  }
16647  }
16648  FCT_TEST_END();
16649 
16650 
16651  FCT_TEST_BGN(gcm_nist_validation_aes_25612800112_0)
16652  {
16653  unsigned char key_str[128];
16654  unsigned char src_str[128];
16655  unsigned char dst_str[257];
16656  unsigned char iv_str[128];
16657  unsigned char add_str[128];
16658  unsigned char tag_str[128];
16659  unsigned char output[128];
16660  gcm_context ctx;
16661  unsigned int key_len;
16662  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
16663  int ret;
16664 
16665  memset(key_str, 0x00, 128);
16666  memset(src_str, 0x00, 128);
16667  memset(dst_str, 0x00, 257);
16668  memset(iv_str, 0x00, 128);
16669  memset(add_str, 0x00, 128);
16670  memset(tag_str, 0x00, 128);
16671  memset(output, 0x00, 128);
16672 
16673  key_len = unhexify( key_str, "4c152ba30aefa5b2a08b0b4d9bf3f16fc208bb0bc4c4eca9411dc262d9276bad" );
16674  pt_len = unhexify( src_str, "" );
16675  iv_len = unhexify( iv_str, "008d040fbd7342464209f330cf56722c" );
16676  add_len = unhexify( add_str, "" );
16677  unhexify( tag_str, "c87107585751e666bedae2b1b7e8" );
16678 
16679  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16680  if( 0 == 0 )
16681  {
16682  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16683 
16684  if( strcmp( "FAIL", "FAIL" ) == 0 )
16685  {
16686  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16687  }
16688  else
16689  {
16690  hexify( dst_str, output, pt_len );
16691 
16692  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16693  }
16694  }
16695  }
16696  FCT_TEST_END();
16697 
16698 
16699  FCT_TEST_BGN(gcm_nist_validation_aes_25612800112_1)
16700  {
16701  unsigned char key_str[128];
16702  unsigned char src_str[128];
16703  unsigned char dst_str[257];
16704  unsigned char iv_str[128];
16705  unsigned char add_str[128];
16706  unsigned char tag_str[128];
16707  unsigned char output[128];
16708  gcm_context ctx;
16709  unsigned int key_len;
16710  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
16711  int ret;
16712 
16713  memset(key_str, 0x00, 128);
16714  memset(src_str, 0x00, 128);
16715  memset(dst_str, 0x00, 257);
16716  memset(iv_str, 0x00, 128);
16717  memset(add_str, 0x00, 128);
16718  memset(tag_str, 0x00, 128);
16719  memset(output, 0x00, 128);
16720 
16721  key_len = unhexify( key_str, "9aed4ae6b1d857fdcbe5aec6db38440613dcc49f24aa31fba1f300b2585723f1" );
16722  pt_len = unhexify( src_str, "" );
16723  iv_len = unhexify( iv_str, "947c5f0432723f2d7b560eca90842df1" );
16724  add_len = unhexify( add_str, "" );
16725  unhexify( tag_str, "7d331fedcea0fd1e9e6a84385467" );
16726 
16727  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16728  if( 0 == 0 )
16729  {
16730  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16731 
16732  if( strcmp( "FAIL", "FAIL" ) == 0 )
16733  {
16734  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16735  }
16736  else
16737  {
16738  hexify( dst_str, output, pt_len );
16739 
16740  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16741  }
16742  }
16743  }
16744  FCT_TEST_END();
16745 
16746 
16747  FCT_TEST_BGN(gcm_nist_validation_aes_25612800112_2)
16748  {
16749  unsigned char key_str[128];
16750  unsigned char src_str[128];
16751  unsigned char dst_str[257];
16752  unsigned char iv_str[128];
16753  unsigned char add_str[128];
16754  unsigned char tag_str[128];
16755  unsigned char output[128];
16756  gcm_context ctx;
16757  unsigned int key_len;
16758  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
16759  int ret;
16760 
16761  memset(key_str, 0x00, 128);
16762  memset(src_str, 0x00, 128);
16763  memset(dst_str, 0x00, 257);
16764  memset(iv_str, 0x00, 128);
16765  memset(add_str, 0x00, 128);
16766  memset(tag_str, 0x00, 128);
16767  memset(output, 0x00, 128);
16768 
16769  key_len = unhexify( key_str, "cc80bc031676eff5f34dd076388a5130e985f9e06df4b4bf8490ff9ff20aae73" );
16770  pt_len = unhexify( src_str, "" );
16771  iv_len = unhexify( iv_str, "51f639467083377795111d44f7d16592" );
16772  add_len = unhexify( add_str, "" );
16773  unhexify( tag_str, "02d31f29e15f60ae3bee1ad7ea65" );
16774 
16775  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16776  if( 0 == 0 )
16777  {
16778  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16779 
16780  if( strcmp( "FAIL", "" ) == 0 )
16781  {
16782  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16783  }
16784  else
16785  {
16786  hexify( dst_str, output, pt_len );
16787 
16788  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
16789  }
16790  }
16791  }
16792  FCT_TEST_END();
16793 
16794 
16795  FCT_TEST_BGN(gcm_nist_validation_aes_25612800104_0)
16796  {
16797  unsigned char key_str[128];
16798  unsigned char src_str[128];
16799  unsigned char dst_str[257];
16800  unsigned char iv_str[128];
16801  unsigned char add_str[128];
16802  unsigned char tag_str[128];
16803  unsigned char output[128];
16804  gcm_context ctx;
16805  unsigned int key_len;
16806  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
16807  int ret;
16808 
16809  memset(key_str, 0x00, 128);
16810  memset(src_str, 0x00, 128);
16811  memset(dst_str, 0x00, 257);
16812  memset(iv_str, 0x00, 128);
16813  memset(add_str, 0x00, 128);
16814  memset(tag_str, 0x00, 128);
16815  memset(output, 0x00, 128);
16816 
16817  key_len = unhexify( key_str, "db7a40213b5b4b07e9900dc28f599403b0579cbce13fcd44dff090062f952686" );
16818  pt_len = unhexify( src_str, "" );
16819  iv_len = unhexify( iv_str, "aea6f8690f865bca9f77a5ff843d2365" );
16820  add_len = unhexify( add_str, "" );
16821  unhexify( tag_str, "7f2280776d6cd6802b3c85083c" );
16822 
16823  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16824  if( 0 == 0 )
16825  {
16826  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16827 
16828  if( strcmp( "FAIL", "FAIL" ) == 0 )
16829  {
16830  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16831  }
16832  else
16833  {
16834  hexify( dst_str, output, pt_len );
16835 
16836  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16837  }
16838  }
16839  }
16840  FCT_TEST_END();
16841 
16842 
16843  FCT_TEST_BGN(gcm_nist_validation_aes_25612800104_1)
16844  {
16845  unsigned char key_str[128];
16846  unsigned char src_str[128];
16847  unsigned char dst_str[257];
16848  unsigned char iv_str[128];
16849  unsigned char add_str[128];
16850  unsigned char tag_str[128];
16851  unsigned char output[128];
16852  gcm_context ctx;
16853  unsigned int key_len;
16854  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
16855  int ret;
16856 
16857  memset(key_str, 0x00, 128);
16858  memset(src_str, 0x00, 128);
16859  memset(dst_str, 0x00, 257);
16860  memset(iv_str, 0x00, 128);
16861  memset(add_str, 0x00, 128);
16862  memset(tag_str, 0x00, 128);
16863  memset(output, 0x00, 128);
16864 
16865  key_len = unhexify( key_str, "299b874eaa8b7baf769f81f4988a41e2708ae928e69a5ba7b893e8e6b2db5c3b" );
16866  pt_len = unhexify( src_str, "" );
16867  iv_len = unhexify( iv_str, "2aa04d85d2c0dc6f5294cb71c0d89ac1" );
16868  add_len = unhexify( add_str, "" );
16869  unhexify( tag_str, "ea01723a22838ed65ceb80b1cf" );
16870 
16871  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16872  if( 0 == 0 )
16873  {
16874  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16875 
16876  if( strcmp( "FAIL", "" ) == 0 )
16877  {
16878  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16879  }
16880  else
16881  {
16882  hexify( dst_str, output, pt_len );
16883 
16884  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
16885  }
16886  }
16887  }
16888  FCT_TEST_END();
16889 
16890 
16891  FCT_TEST_BGN(gcm_nist_validation_aes_25612800104_2)
16892  {
16893  unsigned char key_str[128];
16894  unsigned char src_str[128];
16895  unsigned char dst_str[257];
16896  unsigned char iv_str[128];
16897  unsigned char add_str[128];
16898  unsigned char tag_str[128];
16899  unsigned char output[128];
16900  gcm_context ctx;
16901  unsigned int key_len;
16902  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
16903  int ret;
16904 
16905  memset(key_str, 0x00, 128);
16906  memset(src_str, 0x00, 128);
16907  memset(dst_str, 0x00, 257);
16908  memset(iv_str, 0x00, 128);
16909  memset(add_str, 0x00, 128);
16910  memset(tag_str, 0x00, 128);
16911  memset(output, 0x00, 128);
16912 
16913  key_len = unhexify( key_str, "a6c7b4c8175db4cf23d0593ed8ea949043880fc02e2725f0ab90ae638f9dcfce" );
16914  pt_len = unhexify( src_str, "" );
16915  iv_len = unhexify( iv_str, "ae07f8c7ac82c4f4c086e04a20db12bc" );
16916  add_len = unhexify( add_str, "" );
16917  unhexify( tag_str, "1132e4fff06db51ff135ed9ced" );
16918 
16919  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16920  if( 0 == 0 )
16921  {
16922  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16923 
16924  if( strcmp( "FAIL", "FAIL" ) == 0 )
16925  {
16926  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16927  }
16928  else
16929  {
16930  hexify( dst_str, output, pt_len );
16931 
16932  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16933  }
16934  }
16935  }
16936  FCT_TEST_END();
16937 
16938 
16939  FCT_TEST_BGN(gcm_nist_validation_aes_2561280096_0)
16940  {
16941  unsigned char key_str[128];
16942  unsigned char src_str[128];
16943  unsigned char dst_str[257];
16944  unsigned char iv_str[128];
16945  unsigned char add_str[128];
16946  unsigned char tag_str[128];
16947  unsigned char output[128];
16948  gcm_context ctx;
16949  unsigned int key_len;
16950  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
16951  int ret;
16952 
16953  memset(key_str, 0x00, 128);
16954  memset(src_str, 0x00, 128);
16955  memset(dst_str, 0x00, 257);
16956  memset(iv_str, 0x00, 128);
16957  memset(add_str, 0x00, 128);
16958  memset(tag_str, 0x00, 128);
16959  memset(output, 0x00, 128);
16960 
16961  key_len = unhexify( key_str, "b98e1bf76828b65a81005449971fdc8b11be546d31de6616cd73c5813050c326" );
16962  pt_len = unhexify( src_str, "" );
16963  iv_len = unhexify( iv_str, "929b006eb30d69b49a7f52392d7d3f11" );
16964  add_len = unhexify( add_str, "" );
16965  unhexify( tag_str, "33940d330f7c019a57b74f2d" );
16966 
16967  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
16968  if( 0 == 0 )
16969  {
16970  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
16971 
16972  if( strcmp( "FAIL", "FAIL" ) == 0 )
16973  {
16974  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
16975  }
16976  else
16977  {
16978  hexify( dst_str, output, pt_len );
16979 
16980  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
16981  }
16982  }
16983  }
16984  FCT_TEST_END();
16985 
16986 
16987  FCT_TEST_BGN(gcm_nist_validation_aes_2561280096_1)
16988  {
16989  unsigned char key_str[128];
16990  unsigned char src_str[128];
16991  unsigned char dst_str[257];
16992  unsigned char iv_str[128];
16993  unsigned char add_str[128];
16994  unsigned char tag_str[128];
16995  unsigned char output[128];
16996  gcm_context ctx;
16997  unsigned int key_len;
16998  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
16999  int ret;
17000 
17001  memset(key_str, 0x00, 128);
17002  memset(src_str, 0x00, 128);
17003  memset(dst_str, 0x00, 257);
17004  memset(iv_str, 0x00, 128);
17005  memset(add_str, 0x00, 128);
17006  memset(tag_str, 0x00, 128);
17007  memset(output, 0x00, 128);
17008 
17009  key_len = unhexify( key_str, "09ccef64ae761a70fe16772cba462b058a69477c91595de26a5f1bd637c3816f" );
17010  pt_len = unhexify( src_str, "" );
17011  iv_len = unhexify( iv_str, "e34b19381f05693f7606ce043626664d" );
17012  add_len = unhexify( add_str, "" );
17013  unhexify( tag_str, "2adc2c45947bfa7faa5c464a" );
17014 
17015  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17016  if( 0 == 0 )
17017  {
17018  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17019 
17020  if( strcmp( "FAIL", "FAIL" ) == 0 )
17021  {
17022  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17023  }
17024  else
17025  {
17026  hexify( dst_str, output, pt_len );
17027 
17028  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17029  }
17030  }
17031  }
17032  FCT_TEST_END();
17033 
17034 
17035  FCT_TEST_BGN(gcm_nist_validation_aes_2561280096_2)
17036  {
17037  unsigned char key_str[128];
17038  unsigned char src_str[128];
17039  unsigned char dst_str[257];
17040  unsigned char iv_str[128];
17041  unsigned char add_str[128];
17042  unsigned char tag_str[128];
17043  unsigned char output[128];
17044  gcm_context ctx;
17045  unsigned int key_len;
17046  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
17047  int ret;
17048 
17049  memset(key_str, 0x00, 128);
17050  memset(src_str, 0x00, 128);
17051  memset(dst_str, 0x00, 257);
17052  memset(iv_str, 0x00, 128);
17053  memset(add_str, 0x00, 128);
17054  memset(tag_str, 0x00, 128);
17055  memset(output, 0x00, 128);
17056 
17057  key_len = unhexify( key_str, "654cf46598e5ad3e243472a459bcd80f1e026a65429352dbd56e73fcc5895d1c" );
17058  pt_len = unhexify( src_str, "" );
17059  iv_len = unhexify( iv_str, "a56f27709e670b85e5917d5c1d5b0cc2" );
17060  add_len = unhexify( add_str, "" );
17061  unhexify( tag_str, "177b9a5e6d9731419dd33c5c" );
17062 
17063  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17064  if( 0 == 0 )
17065  {
17066  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17067 
17068  if( strcmp( "FAIL", "" ) == 0 )
17069  {
17070  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17071  }
17072  else
17073  {
17074  hexify( dst_str, output, pt_len );
17075 
17076  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17077  }
17078  }
17079  }
17080  FCT_TEST_END();
17081 
17082 
17083  FCT_TEST_BGN(gcm_nist_validation_aes_2561280064_0)
17084  {
17085  unsigned char key_str[128];
17086  unsigned char src_str[128];
17087  unsigned char dst_str[257];
17088  unsigned char iv_str[128];
17089  unsigned char add_str[128];
17090  unsigned char tag_str[128];
17091  unsigned char output[128];
17092  gcm_context ctx;
17093  unsigned int key_len;
17094  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
17095  int ret;
17096 
17097  memset(key_str, 0x00, 128);
17098  memset(src_str, 0x00, 128);
17099  memset(dst_str, 0x00, 257);
17100  memset(iv_str, 0x00, 128);
17101  memset(add_str, 0x00, 128);
17102  memset(tag_str, 0x00, 128);
17103  memset(output, 0x00, 128);
17104 
17105  key_len = unhexify( key_str, "84bca1b2768b9202bf194f2d5e5a0a5f51fd8bb725f2bab8a3fccbdb64a4ea70" );
17106  pt_len = unhexify( src_str, "" );
17107  iv_len = unhexify( iv_str, "c45b2708c5bdf65ec6cc66b6dfb3623b" );
17108  add_len = unhexify( add_str, "" );
17109  unhexify( tag_str, "fe82300adffd8c17" );
17110 
17111  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17112  if( 0 == 0 )
17113  {
17114  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17115 
17116  if( strcmp( "FAIL", "FAIL" ) == 0 )
17117  {
17118  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17119  }
17120  else
17121  {
17122  hexify( dst_str, output, pt_len );
17123 
17124  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17125  }
17126  }
17127  }
17128  FCT_TEST_END();
17129 
17130 
17131  FCT_TEST_BGN(gcm_nist_validation_aes_2561280064_1)
17132  {
17133  unsigned char key_str[128];
17134  unsigned char src_str[128];
17135  unsigned char dst_str[257];
17136  unsigned char iv_str[128];
17137  unsigned char add_str[128];
17138  unsigned char tag_str[128];
17139  unsigned char output[128];
17140  gcm_context ctx;
17141  unsigned int key_len;
17142  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
17143  int ret;
17144 
17145  memset(key_str, 0x00, 128);
17146  memset(src_str, 0x00, 128);
17147  memset(dst_str, 0x00, 257);
17148  memset(iv_str, 0x00, 128);
17149  memset(add_str, 0x00, 128);
17150  memset(tag_str, 0x00, 128);
17151  memset(output, 0x00, 128);
17152 
17153  key_len = unhexify( key_str, "c8ae011795c9a60ad7660a31fe354fa6f7e9c2724d7a126436291680cd95c007" );
17154  pt_len = unhexify( src_str, "" );
17155  iv_len = unhexify( iv_str, "1bd9ea6186450f9cd253ccfed2812b1c" );
17156  add_len = unhexify( add_str, "" );
17157  unhexify( tag_str, "35214bbc510430e3" );
17158 
17159  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17160  if( 0 == 0 )
17161  {
17162  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17163 
17164  if( strcmp( "FAIL", "" ) == 0 )
17165  {
17166  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17167  }
17168  else
17169  {
17170  hexify( dst_str, output, pt_len );
17171 
17172  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17173  }
17174  }
17175  }
17176  FCT_TEST_END();
17177 
17178 
17179  FCT_TEST_BGN(gcm_nist_validation_aes_2561280064_2)
17180  {
17181  unsigned char key_str[128];
17182  unsigned char src_str[128];
17183  unsigned char dst_str[257];
17184  unsigned char iv_str[128];
17185  unsigned char add_str[128];
17186  unsigned char tag_str[128];
17187  unsigned char output[128];
17188  gcm_context ctx;
17189  unsigned int key_len;
17190  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
17191  int ret;
17192 
17193  memset(key_str, 0x00, 128);
17194  memset(src_str, 0x00, 128);
17195  memset(dst_str, 0x00, 257);
17196  memset(iv_str, 0x00, 128);
17197  memset(add_str, 0x00, 128);
17198  memset(tag_str, 0x00, 128);
17199  memset(output, 0x00, 128);
17200 
17201  key_len = unhexify( key_str, "df2f0a8a3849f497d12bda44e12ce30a6957f3febcd5ec9bc134171326ca66d3" );
17202  pt_len = unhexify( src_str, "" );
17203  iv_len = unhexify( iv_str, "728cb9608b67a489a382aa677b1f4f5b" );
17204  add_len = unhexify( add_str, "" );
17205  unhexify( tag_str, "e2ef5d9cc5791c01" );
17206 
17207  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17208  if( 0 == 0 )
17209  {
17210  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17211 
17212  if( strcmp( "FAIL", "" ) == 0 )
17213  {
17214  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17215  }
17216  else
17217  {
17218  hexify( dst_str, output, pt_len );
17219 
17220  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17221  }
17222  }
17223  }
17224  FCT_TEST_END();
17225 
17226 
17227  FCT_TEST_BGN(gcm_nist_validation_aes_2561280032_0)
17228  {
17229  unsigned char key_str[128];
17230  unsigned char src_str[128];
17231  unsigned char dst_str[257];
17232  unsigned char iv_str[128];
17233  unsigned char add_str[128];
17234  unsigned char tag_str[128];
17235  unsigned char output[128];
17236  gcm_context ctx;
17237  unsigned int key_len;
17238  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
17239  int ret;
17240 
17241  memset(key_str, 0x00, 128);
17242  memset(src_str, 0x00, 128);
17243  memset(dst_str, 0x00, 257);
17244  memset(iv_str, 0x00, 128);
17245  memset(add_str, 0x00, 128);
17246  memset(tag_str, 0x00, 128);
17247  memset(output, 0x00, 128);
17248 
17249  key_len = unhexify( key_str, "78e8a8ad1ecd17446cf9cd9c56facfd4e10faf5762da0fd0da177f6a9b9c3a71" );
17250  pt_len = unhexify( src_str, "" );
17251  iv_len = unhexify( iv_str, "f169ce6f3ccc58f6434ae2b8ad1a63a1" );
17252  add_len = unhexify( add_str, "" );
17253  unhexify( tag_str, "0fe57572" );
17254 
17255  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17256  if( 0 == 0 )
17257  {
17258  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17259 
17260  if( strcmp( "FAIL", "" ) == 0 )
17261  {
17262  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17263  }
17264  else
17265  {
17266  hexify( dst_str, output, pt_len );
17267 
17268  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17269  }
17270  }
17271  }
17272  FCT_TEST_END();
17273 
17274 
17275  FCT_TEST_BGN(gcm_nist_validation_aes_2561280032_1)
17276  {
17277  unsigned char key_str[128];
17278  unsigned char src_str[128];
17279  unsigned char dst_str[257];
17280  unsigned char iv_str[128];
17281  unsigned char add_str[128];
17282  unsigned char tag_str[128];
17283  unsigned char output[128];
17284  gcm_context ctx;
17285  unsigned int key_len;
17286  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
17287  int ret;
17288 
17289  memset(key_str, 0x00, 128);
17290  memset(src_str, 0x00, 128);
17291  memset(dst_str, 0x00, 257);
17292  memset(iv_str, 0x00, 128);
17293  memset(add_str, 0x00, 128);
17294  memset(tag_str, 0x00, 128);
17295  memset(output, 0x00, 128);
17296 
17297  key_len = unhexify( key_str, "02ca6d8a862e25db9d68e4404abc107e700135df4157cfb135ce98eaa33151c9" );
17298  pt_len = unhexify( src_str, "" );
17299  iv_len = unhexify( iv_str, "7b722fdd43cff20832812f9baf2d6791" );
17300  add_len = unhexify( add_str, "" );
17301  unhexify( tag_str, "72dea6cc" );
17302 
17303  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17304  if( 0 == 0 )
17305  {
17306  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17307 
17308  if( strcmp( "FAIL", "FAIL" ) == 0 )
17309  {
17310  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17311  }
17312  else
17313  {
17314  hexify( dst_str, output, pt_len );
17315 
17316  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17317  }
17318  }
17319  }
17320  FCT_TEST_END();
17321 
17322 
17323  FCT_TEST_BGN(gcm_nist_validation_aes_2561280032_2)
17324  {
17325  unsigned char key_str[128];
17326  unsigned char src_str[128];
17327  unsigned char dst_str[257];
17328  unsigned char iv_str[128];
17329  unsigned char add_str[128];
17330  unsigned char tag_str[128];
17331  unsigned char output[128];
17332  gcm_context ctx;
17333  unsigned int key_len;
17334  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
17335  int ret;
17336 
17337  memset(key_str, 0x00, 128);
17338  memset(src_str, 0x00, 128);
17339  memset(dst_str, 0x00, 257);
17340  memset(iv_str, 0x00, 128);
17341  memset(add_str, 0x00, 128);
17342  memset(tag_str, 0x00, 128);
17343  memset(output, 0x00, 128);
17344 
17345  key_len = unhexify( key_str, "9a2b709dbcc3a4fb15b3ad541fb008c381b7e985b57df52f07ca7cd26ab1ecc4" );
17346  pt_len = unhexify( src_str, "" );
17347  iv_len = unhexify( iv_str, "729baa4c0ef75ed8aae746376b39fe3c" );
17348  add_len = unhexify( add_str, "" );
17349  unhexify( tag_str, "2a0d607c" );
17350 
17351  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17352  if( 0 == 0 )
17353  {
17354  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17355 
17356  if( strcmp( "FAIL", "FAIL" ) == 0 )
17357  {
17358  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17359  }
17360  else
17361  {
17362  hexify( dst_str, output, pt_len );
17363 
17364  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17365  }
17366  }
17367  }
17368  FCT_TEST_END();
17369 
17370 
17371  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024128_0)
17372  {
17373  unsigned char key_str[128];
17374  unsigned char src_str[128];
17375  unsigned char dst_str[257];
17376  unsigned char iv_str[128];
17377  unsigned char add_str[128];
17378  unsigned char tag_str[128];
17379  unsigned char output[128];
17380  gcm_context ctx;
17381  unsigned int key_len;
17382  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
17383  int ret;
17384 
17385  memset(key_str, 0x00, 128);
17386  memset(src_str, 0x00, 128);
17387  memset(dst_str, 0x00, 257);
17388  memset(iv_str, 0x00, 128);
17389  memset(add_str, 0x00, 128);
17390  memset(tag_str, 0x00, 128);
17391  memset(output, 0x00, 128);
17392 
17393  key_len = unhexify( key_str, "449d39f863e4909984b37f2e5c09ea4d4b3e9fac67bd57c299e4e1d1f084aaa3" );
17394  pt_len = unhexify( src_str, "" );
17395  iv_len = unhexify( iv_str, "d8e9118f331bb5a359f0aa8882861b72" );
17396  add_len = unhexify( add_str, "4ddcae0bc24d622e12bdeaac73e8d1ab7957af051d27dfaafce53aeed4cdd3f989ea25989a2f41cfb3c38dbd841c5560b0b5ab1861b1fbcd236865d13da55b50219462e021f8a21848a64a85326031fcec8fe47a6ef4a435dd2b2fff637644ffcf3914ef2dfa5dd556421bfd297be150b31db039f0f2cc422b282e659e70cceb" );
17397  unhexify( tag_str, "c595b9d99414891228c9fa5edb5fcce3" );
17398 
17399  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17400  if( 0 == 0 )
17401  {
17402  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17403 
17404  if( strcmp( "FAIL", "" ) == 0 )
17405  {
17406  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17407  }
17408  else
17409  {
17410  hexify( dst_str, output, pt_len );
17411 
17412  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17413  }
17414  }
17415  }
17416  FCT_TEST_END();
17417 
17418 
17419  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024128_1)
17420  {
17421  unsigned char key_str[128];
17422  unsigned char src_str[128];
17423  unsigned char dst_str[257];
17424  unsigned char iv_str[128];
17425  unsigned char add_str[128];
17426  unsigned char tag_str[128];
17427  unsigned char output[128];
17428  gcm_context ctx;
17429  unsigned int key_len;
17430  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
17431  int ret;
17432 
17433  memset(key_str, 0x00, 128);
17434  memset(src_str, 0x00, 128);
17435  memset(dst_str, 0x00, 257);
17436  memset(iv_str, 0x00, 128);
17437  memset(add_str, 0x00, 128);
17438  memset(tag_str, 0x00, 128);
17439  memset(output, 0x00, 128);
17440 
17441  key_len = unhexify( key_str, "3e70e66813fc48f984dcda4d1c9c24f1d5d1b71ecfc8bb9581782e7cca5a5cc6" );
17442  pt_len = unhexify( src_str, "" );
17443  iv_len = unhexify( iv_str, "d804f1051e72c9b7117002b862eb45ff" );
17444  add_len = unhexify( add_str, "0b1ab2b7a87cebac668c7a532fa8fa56a22cabf0c41fc1e6744ffe07c857c6865d623f508351f98f3f0c577d1eb94300a30a445472218c8ac626b0bee7d4c122d33f8130436a89add341e8ef7e00694afb4ad80d314d87ad3f921c7105eed05431b8151df7cff2c8e3790efd4acd3f60332dc7f34fdd90beef70f9093361d65b" );
17445  unhexify( tag_str, "c09c2e3fdfefa222f7345ae4efb978fc" );
17446 
17447  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17448  if( 0 == 0 )
17449  {
17450  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17451 
17452  if( strcmp( "FAIL", "FAIL" ) == 0 )
17453  {
17454  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17455  }
17456  else
17457  {
17458  hexify( dst_str, output, pt_len );
17459 
17460  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17461  }
17462  }
17463  }
17464  FCT_TEST_END();
17465 
17466 
17467  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024128_2)
17468  {
17469  unsigned char key_str[128];
17470  unsigned char src_str[128];
17471  unsigned char dst_str[257];
17472  unsigned char iv_str[128];
17473  unsigned char add_str[128];
17474  unsigned char tag_str[128];
17475  unsigned char output[128];
17476  gcm_context ctx;
17477  unsigned int key_len;
17478  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
17479  int ret;
17480 
17481  memset(key_str, 0x00, 128);
17482  memset(src_str, 0x00, 128);
17483  memset(dst_str, 0x00, 257);
17484  memset(iv_str, 0x00, 128);
17485  memset(add_str, 0x00, 128);
17486  memset(tag_str, 0x00, 128);
17487  memset(output, 0x00, 128);
17488 
17489  key_len = unhexify( key_str, "8e534041090b45b80f287dc5fa20ebda017ad81b0530e680f62c6280fd8881af" );
17490  pt_len = unhexify( src_str, "" );
17491  iv_len = unhexify( iv_str, "ead675b019ef5c6bbf4985f2a382d6c1" );
17492  add_len = unhexify( add_str, "b1db220052c4bebcef27eed6db0dc91be481179d71160c5a2ddb2fe497a05484840b04cce48980057d770fbbd0d5f3d5c633b55470617ad2cab5767188283310337825c4b0eafe13b5b11293dec230dad43b220885105767938c7ec4600fe063f98aa14bc6afb886fc874c10546749da295f571e696305bd9165486e29f43f52" );
17493  unhexify( tag_str, "9aa0cdad5686ca515cd58aed94938ef4" );
17494 
17495  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17496  if( 0 == 0 )
17497  {
17498  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17499 
17500  if( strcmp( "FAIL", "FAIL" ) == 0 )
17501  {
17502  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17503  }
17504  else
17505  {
17506  hexify( dst_str, output, pt_len );
17507 
17508  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17509  }
17510  }
17511  }
17512  FCT_TEST_END();
17513 
17514 
17515  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024120_0)
17516  {
17517  unsigned char key_str[128];
17518  unsigned char src_str[128];
17519  unsigned char dst_str[257];
17520  unsigned char iv_str[128];
17521  unsigned char add_str[128];
17522  unsigned char tag_str[128];
17523  unsigned char output[128];
17524  gcm_context ctx;
17525  unsigned int key_len;
17526  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
17527  int ret;
17528 
17529  memset(key_str, 0x00, 128);
17530  memset(src_str, 0x00, 128);
17531  memset(dst_str, 0x00, 257);
17532  memset(iv_str, 0x00, 128);
17533  memset(add_str, 0x00, 128);
17534  memset(tag_str, 0x00, 128);
17535  memset(output, 0x00, 128);
17536 
17537  key_len = unhexify( key_str, "2de18874470c09db683cf45cd752bdfa8bf33e7967220b1a69f41f2a02da1d80" );
17538  pt_len = unhexify( src_str, "" );
17539  iv_len = unhexify( iv_str, "af30eb2d0a0c2a50ea413f3285aa88d4" );
17540  add_len = unhexify( add_str, "22889b868d8ccc9f488406813caed199b23091ddd796c8632f564e7cf5a39dfb725266a931fec958659b6fc5b6b9343b8217edb0acb010afc9416601155262b57bd398d62f555953f0e15958e19ae004fbc9cb25e0269a9eaa38a4635a27bfa719fb249fa49337796bcf5f416bba87fbf3b19f0d8c11290c25ca50bbdc822f01" );
17541  unhexify( tag_str, "646bbc9b14681af65b0d1c4c9f1d0d" );
17542 
17543  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17544  if( 0 == 0 )
17545  {
17546  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17547 
17548  if( strcmp( "FAIL", "FAIL" ) == 0 )
17549  {
17550  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17551  }
17552  else
17553  {
17554  hexify( dst_str, output, pt_len );
17555 
17556  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17557  }
17558  }
17559  }
17560  FCT_TEST_END();
17561 
17562 
17563  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024120_1)
17564  {
17565  unsigned char key_str[128];
17566  unsigned char src_str[128];
17567  unsigned char dst_str[257];
17568  unsigned char iv_str[128];
17569  unsigned char add_str[128];
17570  unsigned char tag_str[128];
17571  unsigned char output[128];
17572  gcm_context ctx;
17573  unsigned int key_len;
17574  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
17575  int ret;
17576 
17577  memset(key_str, 0x00, 128);
17578  memset(src_str, 0x00, 128);
17579  memset(dst_str, 0x00, 257);
17580  memset(iv_str, 0x00, 128);
17581  memset(add_str, 0x00, 128);
17582  memset(tag_str, 0x00, 128);
17583  memset(output, 0x00, 128);
17584 
17585  key_len = unhexify( key_str, "1a1bb9122e762ecd7ff861a1d65e52607d98e7ae5bd1c3a944e443710f3b0599" );
17586  pt_len = unhexify( src_str, "" );
17587  iv_len = unhexify( iv_str, "32f99ea4cbf52c2701c2252e5e6c863d" );
17588  add_len = unhexify( add_str, "91b7a70c3a06c1f7f2ea584acb5dd76177ba07323c94f2e8f7cbe93fc0bb7c389c3c88e16aa53174f0fc373bc778a6ccf91bf61b6e92c2969d3441eb17a0a835d30dcf882472a6d3cb036533b04d79f05ebfaadf221ae1c14af3f02fa41867acfdfa35f81e8a9d11d42b9a63288c759063c0c3040c3e6ee69cf7c75f9c33fea1" );
17589  unhexify( tag_str, "a8e29e08623a3efdbbe8b111de30a4" );
17590 
17591  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17592  if( 0 == 0 )
17593  {
17594  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17595 
17596  if( strcmp( "FAIL", "FAIL" ) == 0 )
17597  {
17598  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17599  }
17600  else
17601  {
17602  hexify( dst_str, output, pt_len );
17603 
17604  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17605  }
17606  }
17607  }
17608  FCT_TEST_END();
17609 
17610 
17611  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024120_2)
17612  {
17613  unsigned char key_str[128];
17614  unsigned char src_str[128];
17615  unsigned char dst_str[257];
17616  unsigned char iv_str[128];
17617  unsigned char add_str[128];
17618  unsigned char tag_str[128];
17619  unsigned char output[128];
17620  gcm_context ctx;
17621  unsigned int key_len;
17622  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
17623  int ret;
17624 
17625  memset(key_str, 0x00, 128);
17626  memset(src_str, 0x00, 128);
17627  memset(dst_str, 0x00, 257);
17628  memset(iv_str, 0x00, 128);
17629  memset(add_str, 0x00, 128);
17630  memset(tag_str, 0x00, 128);
17631  memset(output, 0x00, 128);
17632 
17633  key_len = unhexify( key_str, "3bfad1e8f9850577f9ba3f290e9a5e91b494c2d99534220362e171a7543177ac" );
17634  pt_len = unhexify( src_str, "" );
17635  iv_len = unhexify( iv_str, "8410886b70c57d7ded8596443bd1b157" );
17636  add_len = unhexify( add_str, "ca801c83596795515ea931edba00e06e332bf84246b7036e10b317e2d09a51b2981fcb664ee3bf4180bb0b12ed1cda221abc6790b27c26914f5ef9cea9536e2453cd5b247cb054e295c2687b725a97cbc484b8eb86c6ceee03bd07a54a9301a3ac0ddb23aecb825a238252e7575329058b40e75575a7f16439edf5be163ce5f5" );
17637  unhexify( tag_str, "e3645db0c600dba52044efcecfc331" );
17638 
17639  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17640  if( 0 == 0 )
17641  {
17642  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17643 
17644  if( strcmp( "FAIL", "FAIL" ) == 0 )
17645  {
17646  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17647  }
17648  else
17649  {
17650  hexify( dst_str, output, pt_len );
17651 
17652  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17653  }
17654  }
17655  }
17656  FCT_TEST_END();
17657 
17658 
17659  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024112_0)
17660  {
17661  unsigned char key_str[128];
17662  unsigned char src_str[128];
17663  unsigned char dst_str[257];
17664  unsigned char iv_str[128];
17665  unsigned char add_str[128];
17666  unsigned char tag_str[128];
17667  unsigned char output[128];
17668  gcm_context ctx;
17669  unsigned int key_len;
17670  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
17671  int ret;
17672 
17673  memset(key_str, 0x00, 128);
17674  memset(src_str, 0x00, 128);
17675  memset(dst_str, 0x00, 257);
17676  memset(iv_str, 0x00, 128);
17677  memset(add_str, 0x00, 128);
17678  memset(tag_str, 0x00, 128);
17679  memset(output, 0x00, 128);
17680 
17681  key_len = unhexify( key_str, "65debdf2f2191a6cd8de8ad4d5d4d0d8f731f67744e2545df6b2a7cba89c1ee0" );
17682  pt_len = unhexify( src_str, "" );
17683  iv_len = unhexify( iv_str, "fdab2ee547dd8b6f5a4ea2dd19697b3e" );
17684  add_len = unhexify( add_str, "d2b0a0438ee0f145aec9a7ca452b788ecb473152b78fb75f6ace721afc7b0ae1942049b790f3a5b6221a8760295659756d35347cc04029be03459f3e23a71209b4e0bbe13a253a888c83db23376d3a6d9a539f7c9fa4a12dc64297e7c93dfa0ab53ef76b6e1d95bf6f3d5e6ee8f08662fc03ec9d40eff0a43f23ac313671bfd9" );
17685  unhexify( tag_str, "c25fc157c3f2474885e2eea48aea" );
17686 
17687  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17688  if( 0 == 0 )
17689  {
17690  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17691 
17692  if( strcmp( "FAIL", "" ) == 0 )
17693  {
17694  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17695  }
17696  else
17697  {
17698  hexify( dst_str, output, pt_len );
17699 
17700  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17701  }
17702  }
17703  }
17704  FCT_TEST_END();
17705 
17706 
17707  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024112_1)
17708  {
17709  unsigned char key_str[128];
17710  unsigned char src_str[128];
17711  unsigned char dst_str[257];
17712  unsigned char iv_str[128];
17713  unsigned char add_str[128];
17714  unsigned char tag_str[128];
17715  unsigned char output[128];
17716  gcm_context ctx;
17717  unsigned int key_len;
17718  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
17719  int ret;
17720 
17721  memset(key_str, 0x00, 128);
17722  memset(src_str, 0x00, 128);
17723  memset(dst_str, 0x00, 257);
17724  memset(iv_str, 0x00, 128);
17725  memset(add_str, 0x00, 128);
17726  memset(tag_str, 0x00, 128);
17727  memset(output, 0x00, 128);
17728 
17729  key_len = unhexify( key_str, "496ae810380460d40cd2fdae8c0739f16b87205cc7f57db0a71a473eb361d570" );
17730  pt_len = unhexify( src_str, "" );
17731  iv_len = unhexify( iv_str, "77233de96f5e1744337778212b411bd5" );
17732  add_len = unhexify( add_str, "85f5b54b4c4af5c808120bd28d98e44e96f4126623e57684957e9fc4fd1a2d0583940b8fc8314a249325476e8d05247831b04709580ae714e8187cd38f9559419e14c9fc4f8c454ec191b8ef2a3610988fe3339d0dc6b72f5978f9eff9d596dfabf27056e3a908c6497267461386e860f6b9d65526294bcb92908b5661b06b5a" );
17733  unhexify( tag_str, "4ed91af6340e70b0c2b94ab6f82e" );
17734 
17735  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17736  if( 0 == 0 )
17737  {
17738  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17739 
17740  if( strcmp( "FAIL", "FAIL" ) == 0 )
17741  {
17742  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17743  }
17744  else
17745  {
17746  hexify( dst_str, output, pt_len );
17747 
17748  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17749  }
17750  }
17751  }
17752  FCT_TEST_END();
17753 
17754 
17755  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024112_2)
17756  {
17757  unsigned char key_str[128];
17758  unsigned char src_str[128];
17759  unsigned char dst_str[257];
17760  unsigned char iv_str[128];
17761  unsigned char add_str[128];
17762  unsigned char tag_str[128];
17763  unsigned char output[128];
17764  gcm_context ctx;
17765  unsigned int key_len;
17766  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
17767  int ret;
17768 
17769  memset(key_str, 0x00, 128);
17770  memset(src_str, 0x00, 128);
17771  memset(dst_str, 0x00, 257);
17772  memset(iv_str, 0x00, 128);
17773  memset(add_str, 0x00, 128);
17774  memset(tag_str, 0x00, 128);
17775  memset(output, 0x00, 128);
17776 
17777  key_len = unhexify( key_str, "aca188183b46139cc7cffc82a6aaaeb2fd73cecad14e75c663bd62daf1ec711d" );
17778  pt_len = unhexify( src_str, "" );
17779  iv_len = unhexify( iv_str, "7bbf7fb55eb70cce94cc6a2b67de55ba" );
17780  add_len = unhexify( add_str, "015cfba90f069545fed60f31992ff3d3c3592eb91e7a53df5978ded64291954cb99a57de82d5398ce782b68d14ac04a8b425395bd076ead59eb445721bdb2f45e19fa089117800cbbac7b8313fb165ccb1122acb654e1242dc7fe6885ea1cbb7281b1270cfa1549cdfe9b47caf47b4ac3807e562e48c066566f5e606b5023b47" );
17781  unhexify( tag_str, "3bcb5c2a4261d75bfa106fb25ee1" );
17782 
17783  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17784  if( 0 == 0 )
17785  {
17786  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17787 
17788  if( strcmp( "FAIL", "" ) == 0 )
17789  {
17790  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17791  }
17792  else
17793  {
17794  hexify( dst_str, output, pt_len );
17795 
17796  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17797  }
17798  }
17799  }
17800  FCT_TEST_END();
17801 
17802 
17803  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024104_0)
17804  {
17805  unsigned char key_str[128];
17806  unsigned char src_str[128];
17807  unsigned char dst_str[257];
17808  unsigned char iv_str[128];
17809  unsigned char add_str[128];
17810  unsigned char tag_str[128];
17811  unsigned char output[128];
17812  gcm_context ctx;
17813  unsigned int key_len;
17814  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
17815  int ret;
17816 
17817  memset(key_str, 0x00, 128);
17818  memset(src_str, 0x00, 128);
17819  memset(dst_str, 0x00, 257);
17820  memset(iv_str, 0x00, 128);
17821  memset(add_str, 0x00, 128);
17822  memset(tag_str, 0x00, 128);
17823  memset(output, 0x00, 128);
17824 
17825  key_len = unhexify( key_str, "8cd6815f6ec15f03b7a53f159e877a5981e0ab7f6e6c261ddde4b47cbb2f2366" );
17826  pt_len = unhexify( src_str, "" );
17827  iv_len = unhexify( iv_str, "c431c07d9adf5f61204a017259cddd75" );
17828  add_len = unhexify( add_str, "4e1a835402bde4f5227e64b46a1f8d0f23a9434e189377fcdf1b9621ba1987eb86a7f3b97ed0babfd674e74c5604a03dd016d71000a72bbbd00a7f7fe56ad0fcb36a3e24dd0fdb63bd66d4db415f35012416ed599796ca3f678df7eb5a1b17f75abb348ddd3b366369a7b362c9488aedab836b61f9a158f0b129c8ca0a53a81e" );
17829  unhexify( tag_str, "0e463806ff34e206f703dd96b3" );
17830 
17831  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17832  if( 0 == 0 )
17833  {
17834  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17835 
17836  if( strcmp( "FAIL", "FAIL" ) == 0 )
17837  {
17838  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17839  }
17840  else
17841  {
17842  hexify( dst_str, output, pt_len );
17843 
17844  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
17845  }
17846  }
17847  }
17848  FCT_TEST_END();
17849 
17850 
17851  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024104_1)
17852  {
17853  unsigned char key_str[128];
17854  unsigned char src_str[128];
17855  unsigned char dst_str[257];
17856  unsigned char iv_str[128];
17857  unsigned char add_str[128];
17858  unsigned char tag_str[128];
17859  unsigned char output[128];
17860  gcm_context ctx;
17861  unsigned int key_len;
17862  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
17863  int ret;
17864 
17865  memset(key_str, 0x00, 128);
17866  memset(src_str, 0x00, 128);
17867  memset(dst_str, 0x00, 257);
17868  memset(iv_str, 0x00, 128);
17869  memset(add_str, 0x00, 128);
17870  memset(tag_str, 0x00, 128);
17871  memset(output, 0x00, 128);
17872 
17873  key_len = unhexify( key_str, "8f0a72abcda104aa7fae501f9a3b686d00d3f6fe984731db8a2865bfec587073" );
17874  pt_len = unhexify( src_str, "" );
17875  iv_len = unhexify( iv_str, "ab8acd063775d1b1314f14e90fddd1be" );
17876  add_len = unhexify( add_str, "02c6d426e7f20b725d8cde0a6382e49b029b52126889013ef45251f27b2fadb95ca4a9a3b16ad06999eeca4a473e813045db4942e9b9ff2e5a5e429d9bac298372344d1b781d5facabf6d779643f31ada6124eb50aad599044b54279ec9b25714ac8a3b9ad2487cec7f4b1ee245d7be3d496d6af1d4cbee1c8201312541f3064" );
17877  unhexify( tag_str, "3f0ccc134091e0c0425887b1b9" );
17878 
17879  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17880  if( 0 == 0 )
17881  {
17882  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17883 
17884  if( strcmp( "FAIL", "" ) == 0 )
17885  {
17886  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17887  }
17888  else
17889  {
17890  hexify( dst_str, output, pt_len );
17891 
17892  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17893  }
17894  }
17895  }
17896  FCT_TEST_END();
17897 
17898 
17899  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024104_2)
17900  {
17901  unsigned char key_str[128];
17902  unsigned char src_str[128];
17903  unsigned char dst_str[257];
17904  unsigned char iv_str[128];
17905  unsigned char add_str[128];
17906  unsigned char tag_str[128];
17907  unsigned char output[128];
17908  gcm_context ctx;
17909  unsigned int key_len;
17910  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
17911  int ret;
17912 
17913  memset(key_str, 0x00, 128);
17914  memset(src_str, 0x00, 128);
17915  memset(dst_str, 0x00, 257);
17916  memset(iv_str, 0x00, 128);
17917  memset(add_str, 0x00, 128);
17918  memset(tag_str, 0x00, 128);
17919  memset(output, 0x00, 128);
17920 
17921  key_len = unhexify( key_str, "417135cad74280e6f8597dc791431c95cb8fa63bbf7197e3ab37c4b1d6d9438a" );
17922  pt_len = unhexify( src_str, "" );
17923  iv_len = unhexify( iv_str, "0fe22d9ba1d0e32656e3a9f07a517a27" );
17924  add_len = unhexify( add_str, "a0b2712e81d329d5b076a4be2ad6823cee6dbd17d9a592d065bdebb92b1ff37a56bf2f5e5341f39c574246ccda19e5f35fede49c9ba958f3920cc5440fb404fab7846884ca0c2a3af5b51f4fe97a1395571319cc5b40f8aac986d77de280db82343983982638326ef003e0c013af19c34672975dc99ccc0853a1acf7c617d965" );
17925  unhexify( tag_str, "888b836c9111073924a9b43069" );
17926 
17927  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17928  if( 0 == 0 )
17929  {
17930  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17931 
17932  if( strcmp( "FAIL", "" ) == 0 )
17933  {
17934  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17935  }
17936  else
17937  {
17938  hexify( dst_str, output, pt_len );
17939 
17940  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17941  }
17942  }
17943  }
17944  FCT_TEST_END();
17945 
17946 
17947  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102496_0)
17948  {
17949  unsigned char key_str[128];
17950  unsigned char src_str[128];
17951  unsigned char dst_str[257];
17952  unsigned char iv_str[128];
17953  unsigned char add_str[128];
17954  unsigned char tag_str[128];
17955  unsigned char output[128];
17956  gcm_context ctx;
17957  unsigned int key_len;
17958  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
17959  int ret;
17960 
17961  memset(key_str, 0x00, 128);
17962  memset(src_str, 0x00, 128);
17963  memset(dst_str, 0x00, 257);
17964  memset(iv_str, 0x00, 128);
17965  memset(add_str, 0x00, 128);
17966  memset(tag_str, 0x00, 128);
17967  memset(output, 0x00, 128);
17968 
17969  key_len = unhexify( key_str, "304824914e32ea0efd61be6972586093349bd2cc2cf0cff44be943682b2dbff5" );
17970  pt_len = unhexify( src_str, "" );
17971  iv_len = unhexify( iv_str, "b6d927a71929029f6766be42746f7cb1" );
17972  add_len = unhexify( add_str, "7281c81c7514f4b17cb125c4649006ef8959a400a1e4d609d277e363e433725fa32346a10bcbd826b6afc8222158920d0a2db1e6fc915e81231c34c3941ecf3c6f94ffe2136190cae3dc39a4277acbc247f36291b5614a8433b1a0780434a6c50521b72ec25145bbd3b192647155d5dd9df9e66762d39592602ea99bf9bfff49" );
17973  unhexify( tag_str, "b6044c4d7f59491f68b2c61e" );
17974 
17975  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
17976  if( 0 == 0 )
17977  {
17978  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
17979 
17980  if( strcmp( "FAIL", "" ) == 0 )
17981  {
17982  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
17983  }
17984  else
17985  {
17986  hexify( dst_str, output, pt_len );
17987 
17988  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
17989  }
17990  }
17991  }
17992  FCT_TEST_END();
17993 
17994 
17995  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102496_1)
17996  {
17997  unsigned char key_str[128];
17998  unsigned char src_str[128];
17999  unsigned char dst_str[257];
18000  unsigned char iv_str[128];
18001  unsigned char add_str[128];
18002  unsigned char tag_str[128];
18003  unsigned char output[128];
18004  gcm_context ctx;
18005  unsigned int key_len;
18006  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
18007  int ret;
18008 
18009  memset(key_str, 0x00, 128);
18010  memset(src_str, 0x00, 128);
18011  memset(dst_str, 0x00, 257);
18012  memset(iv_str, 0x00, 128);
18013  memset(add_str, 0x00, 128);
18014  memset(tag_str, 0x00, 128);
18015  memset(output, 0x00, 128);
18016 
18017  key_len = unhexify( key_str, "8a10e9abe9389738e12a4bb6f553ae81e8bd320e0dfbc05fbae2128c1fde7a23" );
18018  pt_len = unhexify( src_str, "" );
18019  iv_len = unhexify( iv_str, "6da44354e198e3beb54792718becbcc1" );
18020  add_len = unhexify( add_str, "199d754630135b669bf2ec581d3027a569412ab39a78dd9d482e87b778ec65c6473656260c27827e00e566f1e3728fd7bc1853a39d00e43752c6f62c6f9b542a302eea4fd314473674f6926a878ec1e4b475d889126ce6317115aea7660b86ab7f7595695787f6954903f72361c917523615a86d6ce724bd4a20c9257984c0c6" );
18021  unhexify( tag_str, "5c5683e587baf2bd32de3df5" );
18022 
18023  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18024  if( 0 == 0 )
18025  {
18026  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18027 
18028  if( strcmp( "FAIL", "" ) == 0 )
18029  {
18030  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18031  }
18032  else
18033  {
18034  hexify( dst_str, output, pt_len );
18035 
18036  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
18037  }
18038  }
18039  }
18040  FCT_TEST_END();
18041 
18042 
18043  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102496_2)
18044  {
18045  unsigned char key_str[128];
18046  unsigned char src_str[128];
18047  unsigned char dst_str[257];
18048  unsigned char iv_str[128];
18049  unsigned char add_str[128];
18050  unsigned char tag_str[128];
18051  unsigned char output[128];
18052  gcm_context ctx;
18053  unsigned int key_len;
18054  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
18055  int ret;
18056 
18057  memset(key_str, 0x00, 128);
18058  memset(src_str, 0x00, 128);
18059  memset(dst_str, 0x00, 257);
18060  memset(iv_str, 0x00, 128);
18061  memset(add_str, 0x00, 128);
18062  memset(tag_str, 0x00, 128);
18063  memset(output, 0x00, 128);
18064 
18065  key_len = unhexify( key_str, "d164ffde5dd684becaf73e9667e3e6acb316682c41aea247899e104a54dd7a7f" );
18066  pt_len = unhexify( src_str, "" );
18067  iv_len = unhexify( iv_str, "1d388e19e9d7a9750e2fc1187d4b075a" );
18068  add_len = unhexify( add_str, "f166a5b6f91261cda56f1a537f42ffb8aed10af5e0248f8910034b92dbc58d25953f1497f571d31fbf5ec30d92234b440161703851f0e43530418147ce6270fbcb5db33ab819ba8973051908704b6bea8aaca0718947e6aa82498a6e26a813981783ed9bf9d02eb1ea60927530c4700ff21f00179002b27903dd4103bbc5c645" );
18069  unhexify( tag_str, "52e10495105799ead991547b" );
18070 
18071  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18072  if( 0 == 0 )
18073  {
18074  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18075 
18076  if( strcmp( "FAIL", "" ) == 0 )
18077  {
18078  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18079  }
18080  else
18081  {
18082  hexify( dst_str, output, pt_len );
18083 
18084  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
18085  }
18086  }
18087  }
18088  FCT_TEST_END();
18089 
18090 
18091  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102464_0)
18092  {
18093  unsigned char key_str[128];
18094  unsigned char src_str[128];
18095  unsigned char dst_str[257];
18096  unsigned char iv_str[128];
18097  unsigned char add_str[128];
18098  unsigned char tag_str[128];
18099  unsigned char output[128];
18100  gcm_context ctx;
18101  unsigned int key_len;
18102  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
18103  int ret;
18104 
18105  memset(key_str, 0x00, 128);
18106  memset(src_str, 0x00, 128);
18107  memset(dst_str, 0x00, 257);
18108  memset(iv_str, 0x00, 128);
18109  memset(add_str, 0x00, 128);
18110  memset(tag_str, 0x00, 128);
18111  memset(output, 0x00, 128);
18112 
18113  key_len = unhexify( key_str, "2854188c28b15af4b8e528ab25c0950fc1384976f242716c91bddeec06f2fdea" );
18114  pt_len = unhexify( src_str, "" );
18115  iv_len = unhexify( iv_str, "075af9c31f5252b8920092cbd999e7a0" );
18116  add_len = unhexify( add_str, "e9452f71093843a025bb5f655eb6a4e8316ab5946484b11818f22b62f4df75d5891fa3397537093a261dc9a7648b7477ea1f5fc761716e302763364bcab7992595edd0fc1c7f7ac719c879e6616e2007948eb8530065a6cccf73d0fe4a0598819b471b0856e6d90ea0fc0e5d36a30ee925b6b8e5dbf40e77f01efe782c0bb4f7" );
18117  unhexify( tag_str, "6ff8fd87e5a31eb6" );
18118 
18119  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18120  if( 0 == 0 )
18121  {
18122  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18123 
18124  if( strcmp( "FAIL", "FAIL" ) == 0 )
18125  {
18126  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18127  }
18128  else
18129  {
18130  hexify( dst_str, output, pt_len );
18131 
18132  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18133  }
18134  }
18135  }
18136  FCT_TEST_END();
18137 
18138 
18139  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102464_1)
18140  {
18141  unsigned char key_str[128];
18142  unsigned char src_str[128];
18143  unsigned char dst_str[257];
18144  unsigned char iv_str[128];
18145  unsigned char add_str[128];
18146  unsigned char tag_str[128];
18147  unsigned char output[128];
18148  gcm_context ctx;
18149  unsigned int key_len;
18150  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
18151  int ret;
18152 
18153  memset(key_str, 0x00, 128);
18154  memset(src_str, 0x00, 128);
18155  memset(dst_str, 0x00, 257);
18156  memset(iv_str, 0x00, 128);
18157  memset(add_str, 0x00, 128);
18158  memset(tag_str, 0x00, 128);
18159  memset(output, 0x00, 128);
18160 
18161  key_len = unhexify( key_str, "2bfc445ac0365ae6c3c3815fd18bbd0c60ea224f6620d9b6ac442a500221f104" );
18162  pt_len = unhexify( src_str, "" );
18163  iv_len = unhexify( iv_str, "43c5f3367a9955aaee1a0c4d4a330059" );
18164  add_len = unhexify( add_str, "db0bae8ce7c66a8ba2fedec22f236212e9a7ad72b371de285c7dc6d2f6c22df0ce4920e0f03f91eb1653c4490050b9f18a2a047115796f0adc41707d1ffcbf148aed5c82013f557e6c28f49434fc4eb20112f43566f212c48cec9894ac40772fcd9b611ee9444df7b73e35b8a38428ccb064c9c50491d2535e0b539f424db83e" );
18165  unhexify( tag_str, "49aaa806cb2eeadd" );
18166 
18167  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18168  if( 0 == 0 )
18169  {
18170  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18171 
18172  if( strcmp( "FAIL", "FAIL" ) == 0 )
18173  {
18174  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18175  }
18176  else
18177  {
18178  hexify( dst_str, output, pt_len );
18179 
18180  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18181  }
18182  }
18183  }
18184  FCT_TEST_END();
18185 
18186 
18187  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102464_2)
18188  {
18189  unsigned char key_str[128];
18190  unsigned char src_str[128];
18191  unsigned char dst_str[257];
18192  unsigned char iv_str[128];
18193  unsigned char add_str[128];
18194  unsigned char tag_str[128];
18195  unsigned char output[128];
18196  gcm_context ctx;
18197  unsigned int key_len;
18198  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
18199  int ret;
18200 
18201  memset(key_str, 0x00, 128);
18202  memset(src_str, 0x00, 128);
18203  memset(dst_str, 0x00, 257);
18204  memset(iv_str, 0x00, 128);
18205  memset(add_str, 0x00, 128);
18206  memset(tag_str, 0x00, 128);
18207  memset(output, 0x00, 128);
18208 
18209  key_len = unhexify( key_str, "7b828f99aaf751bf22d993ed682e488595617a607ed74aaacbb6b60457453080" );
18210  pt_len = unhexify( src_str, "" );
18211  iv_len = unhexify( iv_str, "d48dac1d8d77e245420feb2598812418" );
18212  add_len = unhexify( add_str, "f50f785f4e7c848a55a616ecf4b6b1e1ca85e16de7100c7e4273d411bd95c1380ee157ba501ba9616980195f34e39f43e335f33253342feb8ed64443483c721b85241a0320b3cac83104de2db47188c61a373fba592ea16feeefdee1f2bb43927396f58151418672ebb74afff5c029503a0d0be81430e81ed443e08b74c03183" );
18213  unhexify( tag_str, "a5b71ecf845b25d0" );
18214 
18215  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18216  if( 0 == 0 )
18217  {
18218  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18219 
18220  if( strcmp( "FAIL", "FAIL" ) == 0 )
18221  {
18222  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18223  }
18224  else
18225  {
18226  hexify( dst_str, output, pt_len );
18227 
18228  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18229  }
18230  }
18231  }
18232  FCT_TEST_END();
18233 
18234 
18235  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102432_0)
18236  {
18237  unsigned char key_str[128];
18238  unsigned char src_str[128];
18239  unsigned char dst_str[257];
18240  unsigned char iv_str[128];
18241  unsigned char add_str[128];
18242  unsigned char tag_str[128];
18243  unsigned char output[128];
18244  gcm_context ctx;
18245  unsigned int key_len;
18246  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
18247  int ret;
18248 
18249  memset(key_str, 0x00, 128);
18250  memset(src_str, 0x00, 128);
18251  memset(dst_str, 0x00, 257);
18252  memset(iv_str, 0x00, 128);
18253  memset(add_str, 0x00, 128);
18254  memset(tag_str, 0x00, 128);
18255  memset(output, 0x00, 128);
18256 
18257  key_len = unhexify( key_str, "7b6da11d69fca3e4c907628d3eb63d95c7e502fc901372fd097e064e70831432" );
18258  pt_len = unhexify( src_str, "" );
18259  iv_len = unhexify( iv_str, "6fe2148f250ea178d4c8ca8423ead87d" );
18260  add_len = unhexify( add_str, "a8097bb74ded776f578eb7588f5ef8915db9bfa7262af700c8e76ee114e07557b6786dd5a60a66b2703e7c9de5d6b42aca92568aec5d1ecc298dbd0edb150b8cc13c9a78698f7674caa94da6cacd1f3ef4ca4238c59830ea725ab3a6284e28966c8c32d9bccfb0cfd6583a5ca309debe86549a6f317d15c5f928cbc7f473310c" );
18261  unhexify( tag_str, "e9cdbc52" );
18262 
18263  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18264  if( 0 == 0 )
18265  {
18266  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18267 
18268  if( strcmp( "FAIL", "FAIL" ) == 0 )
18269  {
18270  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18271  }
18272  else
18273  {
18274  hexify( dst_str, output, pt_len );
18275 
18276  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18277  }
18278  }
18279  }
18280  FCT_TEST_END();
18281 
18282 
18283  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102432_1)
18284  {
18285  unsigned char key_str[128];
18286  unsigned char src_str[128];
18287  unsigned char dst_str[257];
18288  unsigned char iv_str[128];
18289  unsigned char add_str[128];
18290  unsigned char tag_str[128];
18291  unsigned char output[128];
18292  gcm_context ctx;
18293  unsigned int key_len;
18294  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
18295  int ret;
18296 
18297  memset(key_str, 0x00, 128);
18298  memset(src_str, 0x00, 128);
18299  memset(dst_str, 0x00, 257);
18300  memset(iv_str, 0x00, 128);
18301  memset(add_str, 0x00, 128);
18302  memset(tag_str, 0x00, 128);
18303  memset(output, 0x00, 128);
18304 
18305  key_len = unhexify( key_str, "c5ae9328be49e761064080fc213e53e373fd86359a09d0355e2d438d9b8e68f1" );
18306  pt_len = unhexify( src_str, "" );
18307  iv_len = unhexify( iv_str, "a7e3f8660ff925d5c88c5aceffbd7026" );
18308  add_len = unhexify( add_str, "2ddddba7a56cc808aec4602f09ae9bd78887827bf0315d8dbe16821606ef9d117746dd138bf1f23565d1ab8f4cee36d53fe3730632c5df9f12109b16edbeae285bb49dfdd155f5dc97b319a85362d53cc86817b7c1c31e5e87c9f37422f133d00dd0776bd92ab05ce6860573cd911645cfe3fbe515e85f744899a447fe443653" );
18309  unhexify( tag_str, "e35dbac8" );
18310 
18311  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18312  if( 0 == 0 )
18313  {
18314  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18315 
18316  if( strcmp( "FAIL", "FAIL" ) == 0 )
18317  {
18318  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18319  }
18320  else
18321  {
18322  hexify( dst_str, output, pt_len );
18323 
18324  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18325  }
18326  }
18327  }
18328  FCT_TEST_END();
18329 
18330 
18331  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102432_2)
18332  {
18333  unsigned char key_str[128];
18334  unsigned char src_str[128];
18335  unsigned char dst_str[257];
18336  unsigned char iv_str[128];
18337  unsigned char add_str[128];
18338  unsigned char tag_str[128];
18339  unsigned char output[128];
18340  gcm_context ctx;
18341  unsigned int key_len;
18342  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
18343  int ret;
18344 
18345  memset(key_str, 0x00, 128);
18346  memset(src_str, 0x00, 128);
18347  memset(dst_str, 0x00, 257);
18348  memset(iv_str, 0x00, 128);
18349  memset(add_str, 0x00, 128);
18350  memset(tag_str, 0x00, 128);
18351  memset(output, 0x00, 128);
18352 
18353  key_len = unhexify( key_str, "e4f8ca13ba86c658cc7f42d4f029422209efbd101bc10a1df81a42cfb3a0f79f" );
18354  pt_len = unhexify( src_str, "" );
18355  iv_len = unhexify( iv_str, "1a362fa0e4054ba11e4b06d59c8bc9cf" );
18356  add_len = unhexify( add_str, "e7ad5c75aa13659f8ce4b1650c46382645ec67418199b84ea445b8ceef619ef3fbde59ed3d313c459e36fcf87d26ef2b453409b32f1086934c3072c1ef0aac83762d28b1193b9afff2c083ce4300b768b0ae23ff9d3dcf65bc1693f1350da65180620aab205aceacfc683c8be53a332e2d0337a7518d2a5204f9c8d7325a4799" );
18357  unhexify( tag_str, "e7a37f15" );
18358 
18359  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18360  if( 0 == 0 )
18361  {
18362  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18363 
18364  if( strcmp( "FAIL", "FAIL" ) == 0 )
18365  {
18366  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18367  }
18368  else
18369  {
18370  hexify( dst_str, output, pt_len );
18371 
18372  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18373  }
18374  }
18375  }
18376  FCT_TEST_END();
18377 
18378 
18379  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240128_0)
18380  {
18381  unsigned char key_str[128];
18382  unsigned char src_str[128];
18383  unsigned char dst_str[257];
18384  unsigned char iv_str[128];
18385  unsigned char add_str[128];
18386  unsigned char tag_str[128];
18387  unsigned char output[128];
18388  gcm_context ctx;
18389  unsigned int key_len;
18390  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
18391  int ret;
18392 
18393  memset(key_str, 0x00, 128);
18394  memset(src_str, 0x00, 128);
18395  memset(dst_str, 0x00, 257);
18396  memset(iv_str, 0x00, 128);
18397  memset(add_str, 0x00, 128);
18398  memset(tag_str, 0x00, 128);
18399  memset(output, 0x00, 128);
18400 
18401  key_len = unhexify( key_str, "00050a21ca1e72cd0924be31b943c60854be6744577de3dd9d1f4fada4a19ea6" );
18402  pt_len = unhexify( src_str, "693ffd3d92294857a99c702a0799eeca28ab066dd90917b9ea5ef8f6547f1d90b106cbec8ef2c22af9f8efa6c652f2f97c2baf33af14fe9def230d49524bd65909c3df1490f637f99e788dcc042b40e00bd524c91e2427ef991bf77e7b2f770cda6e90076c5dac4cac7ee3958b53ff8ce846c3a96281f53c2c52f5f3e523536f" );
18403  iv_len = unhexify( iv_str, "2fc1afc1395d8409919248709f468496" );
18404  add_len = unhexify( add_str, "" );
18405  unhexify( tag_str, "e39b6a7fd5ac67a2a1cc24d5eb9d9c74" );
18406 
18407  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18408  if( 0 == 0 )
18409  {
18410  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18411 
18412  if( strcmp( "FAIL", "cfcd6b9ff7641829cbadeaa2e56f1f150a099eccf3e378fa4da59794dcc4490aa4f9c5db0ab245bec36a7d4557a572008e42f03bc1baff3c946f23f54a4dc9828f106cf4264e4ab40165839d1085e7795b1ae0950f0ee4a08e46ada501b6b51dee0e518129c9426e5bd44c66674a9f99cfe676f002cfd344c5bbd22d3d91e600" ) == 0 )
18413  {
18414  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18415  }
18416  else
18417  {
18418  hexify( dst_str, output, pt_len );
18419 
18420  fct_chk( strcmp( (char *) dst_str, "cfcd6b9ff7641829cbadeaa2e56f1f150a099eccf3e378fa4da59794dcc4490aa4f9c5db0ab245bec36a7d4557a572008e42f03bc1baff3c946f23f54a4dc9828f106cf4264e4ab40165839d1085e7795b1ae0950f0ee4a08e46ada501b6b51dee0e518129c9426e5bd44c66674a9f99cfe676f002cfd344c5bbd22d3d91e600" ) == 0 );
18421  }
18422  }
18423  }
18424  FCT_TEST_END();
18425 
18426 
18427  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240128_1)
18428  {
18429  unsigned char key_str[128];
18430  unsigned char src_str[128];
18431  unsigned char dst_str[257];
18432  unsigned char iv_str[128];
18433  unsigned char add_str[128];
18434  unsigned char tag_str[128];
18435  unsigned char output[128];
18436  gcm_context ctx;
18437  unsigned int key_len;
18438  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
18439  int ret;
18440 
18441  memset(key_str, 0x00, 128);
18442  memset(src_str, 0x00, 128);
18443  memset(dst_str, 0x00, 257);
18444  memset(iv_str, 0x00, 128);
18445  memset(add_str, 0x00, 128);
18446  memset(tag_str, 0x00, 128);
18447  memset(output, 0x00, 128);
18448 
18449  key_len = unhexify( key_str, "f10965a66255f0c3515af497ccbb257a09f22ec2d57c5edae322a3e6d2d188ef" );
18450  pt_len = unhexify( src_str, "91598690edf2de8b27f9bc7461a84e80811cee544f0542923898328cf157590251f0342cb81d359b5dccc5391a12320d1444c26f24178977dd6705c2b365dc1ece0152c42e2f0ee3162cf886ef5529f4f16a77f3bdd2aeccd405b59addf098521d0d38cc25f1991e11be7ecf24caedb48a2a286d2e560a38fa9001c5a228c4d1" );
18451  iv_len = unhexify( iv_str, "c571ce0e911de5d883dc4a0787483235" );
18452  add_len = unhexify( add_str, "" );
18453  unhexify( tag_str, "6d9d3a5dbc8dce385f092fff14bfffda" );
18454 
18455  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18456  if( 0 == 0 )
18457  {
18458  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18459 
18460  if( strcmp( "FAIL", "2867996e389e09ec0da94d42e77b1e436b50065b09ca4adf1cd03240444ee699dbb7b3fc081a1869ca607d77d5ff9754fc3c997ff0a4ee17543a2ba77886b88a7128bcc51d3450df58ff3a26671b02c1d213df6adb6f7e853080eb46b504517cbaea162710a9bbc2da8b552eb6b0e0cb98e44fcab0a157312be67974678d143e" ) == 0 )
18461  {
18462  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18463  }
18464  else
18465  {
18466  hexify( dst_str, output, pt_len );
18467 
18468  fct_chk( strcmp( (char *) dst_str, "2867996e389e09ec0da94d42e77b1e436b50065b09ca4adf1cd03240444ee699dbb7b3fc081a1869ca607d77d5ff9754fc3c997ff0a4ee17543a2ba77886b88a7128bcc51d3450df58ff3a26671b02c1d213df6adb6f7e853080eb46b504517cbaea162710a9bbc2da8b552eb6b0e0cb98e44fcab0a157312be67974678d143e" ) == 0 );
18469  }
18470  }
18471  }
18472  FCT_TEST_END();
18473 
18474 
18475  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240128_2)
18476  {
18477  unsigned char key_str[128];
18478  unsigned char src_str[128];
18479  unsigned char dst_str[257];
18480  unsigned char iv_str[128];
18481  unsigned char add_str[128];
18482  unsigned char tag_str[128];
18483  unsigned char output[128];
18484  gcm_context ctx;
18485  unsigned int key_len;
18486  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
18487  int ret;
18488 
18489  memset(key_str, 0x00, 128);
18490  memset(src_str, 0x00, 128);
18491  memset(dst_str, 0x00, 257);
18492  memset(iv_str, 0x00, 128);
18493  memset(add_str, 0x00, 128);
18494  memset(tag_str, 0x00, 128);
18495  memset(output, 0x00, 128);
18496 
18497  key_len = unhexify( key_str, "4437ee7d16d8c3ca1aa01e20b66749efa901614d4bb4bee786ad5a5f1bfde2e6" );
18498  pt_len = unhexify( src_str, "ff80727a3485cdbc7fab4ee9fadfdc621c538e2055706629046078f1aa3fb687fc728d3a7ffa52ae457b7b5649613eab7bafa464bb435314c49e5900750f7ad39ca9b75df6b2eaa755439e101f67b7ae4cd80dc4a9dea0027048253f2d0a6014056ca69b8c85605b00cf75fa7634a0ddf464270a8c79ce1a1324c4a4c513b24b" );
18499  iv_len = unhexify( iv_str, "275393276745bc43bae4af1e5d43a31e" );
18500  add_len = unhexify( add_str, "" );
18501  unhexify( tag_str, "a82ff1e87d26e4d6e417b60fb2d3ce23" );
18502 
18503  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18504  if( 0 == 0 )
18505  {
18506  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18507 
18508  if( strcmp( "FAIL", "88f994d276ed20be3932d16f551c4b7e2ed80411f2e72ce098fa0b70c22157a59edab30649fec447dd63f0c87dceca7238ef0d9561b58489ba7bd86f2892743099f40af63c432f78ac0ad0b5c2be47b9e3045e7237b096ee400f430af63a6f309de785caf190f3f4aabbe79f727a741590de542bd343df68d13db55a5f8bab41" ) == 0 )
18509  {
18510  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18511  }
18512  else
18513  {
18514  hexify( dst_str, output, pt_len );
18515 
18516  fct_chk( strcmp( (char *) dst_str, "88f994d276ed20be3932d16f551c4b7e2ed80411f2e72ce098fa0b70c22157a59edab30649fec447dd63f0c87dceca7238ef0d9561b58489ba7bd86f2892743099f40af63c432f78ac0ad0b5c2be47b9e3045e7237b096ee400f430af63a6f309de785caf190f3f4aabbe79f727a741590de542bd343df68d13db55a5f8bab41" ) == 0 );
18517  }
18518  }
18519  }
18520  FCT_TEST_END();
18521 
18522 
18523  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240120_0)
18524  {
18525  unsigned char key_str[128];
18526  unsigned char src_str[128];
18527  unsigned char dst_str[257];
18528  unsigned char iv_str[128];
18529  unsigned char add_str[128];
18530  unsigned char tag_str[128];
18531  unsigned char output[128];
18532  gcm_context ctx;
18533  unsigned int key_len;
18534  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
18535  int ret;
18536 
18537  memset(key_str, 0x00, 128);
18538  memset(src_str, 0x00, 128);
18539  memset(dst_str, 0x00, 257);
18540  memset(iv_str, 0x00, 128);
18541  memset(add_str, 0x00, 128);
18542  memset(tag_str, 0x00, 128);
18543  memset(output, 0x00, 128);
18544 
18545  key_len = unhexify( key_str, "fe4ec037ce563dadee435cfcb2bf090f1f7ccc7d1b5b4fab2f1b738348f8ed2f" );
18546  pt_len = unhexify( src_str, "64eb8a4bda9804c09b04cfcd89094928c21480908b81ee19d6c29c2a3631b1a5bdc8e7f8ea56f7b8b8e14a5208296026785cac3a6afa54be8af4d5faedcd12b6621bde0f8ec5a2635fe72a89468ca7704c73aa40cd2ba97aef08886b27a694d339b00e7d12a31308672f87c06a7388a1432f869eb4cc1da864140b1b33931925" );
18547  iv_len = unhexify( iv_str, "47f5264f7a5b65b671892a05fa556f63" );
18548  add_len = unhexify( add_str, "" );
18549  unhexify( tag_str, "660462b4088f6628a630f2e4170b21" );
18550 
18551  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18552  if( 0 == 0 )
18553  {
18554  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18555 
18556  if( strcmp( "FAIL", "4a310e035361f98b8c54fb4cef70b1a9c910552ece056ca8fdab54c52308ec0ad7fe9dd1dae92badab5010577de522088768fa6466fbccce22e14c51ca7986c4063d0f06bf578dab16a91856713198a7138395c49c78b6314b57ab72fd079028c8dc351952d90b04a7cd2b245df0c0522447cdb7d3329fd9425fe5cb40a8e7c9" ) == 0 )
18557  {
18558  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18559  }
18560  else
18561  {
18562  hexify( dst_str, output, pt_len );
18563 
18564  fct_chk( strcmp( (char *) dst_str, "4a310e035361f98b8c54fb4cef70b1a9c910552ece056ca8fdab54c52308ec0ad7fe9dd1dae92badab5010577de522088768fa6466fbccce22e14c51ca7986c4063d0f06bf578dab16a91856713198a7138395c49c78b6314b57ab72fd079028c8dc351952d90b04a7cd2b245df0c0522447cdb7d3329fd9425fe5cb40a8e7c9" ) == 0 );
18565  }
18566  }
18567  }
18568  FCT_TEST_END();
18569 
18570 
18571  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240120_1)
18572  {
18573  unsigned char key_str[128];
18574  unsigned char src_str[128];
18575  unsigned char dst_str[257];
18576  unsigned char iv_str[128];
18577  unsigned char add_str[128];
18578  unsigned char tag_str[128];
18579  unsigned char output[128];
18580  gcm_context ctx;
18581  unsigned int key_len;
18582  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
18583  int ret;
18584 
18585  memset(key_str, 0x00, 128);
18586  memset(src_str, 0x00, 128);
18587  memset(dst_str, 0x00, 257);
18588  memset(iv_str, 0x00, 128);
18589  memset(add_str, 0x00, 128);
18590  memset(tag_str, 0x00, 128);
18591  memset(output, 0x00, 128);
18592 
18593  key_len = unhexify( key_str, "e6e1ada628ca76eb9832cc6b5efc5c9d2686bb587366a6de2d734233fa95279e" );
18594  pt_len = unhexify( src_str, "a0ac738e0fb35246b84a6fbe319f827039515df25d0c0fc6de7c048253ae63d3c561e44a12672ffeae1cb925610b482aa422bbee0e1784fc69baac3a97d69f51e6d2a17957b44b318624ea7ec680a559f4d3f2761d09bee66efb3a312ae6b3ecb673e756b2a0f654671e82500e7ace91f2be2a74bc3bc1ec1a4b6877a53c27c8" );
18595  iv_len = unhexify( iv_str, "5a100b451e3a63a3e6d4b8a9e59c6bce" );
18596  add_len = unhexify( add_str, "" );
18597  unhexify( tag_str, "88df9a1ea54e5bd2ef24da6880b79d" );
18598 
18599  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18600  if( 0 == 0 )
18601  {
18602  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18603 
18604  if( strcmp( "FAIL", "FAIL" ) == 0 )
18605  {
18606  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18607  }
18608  else
18609  {
18610  hexify( dst_str, output, pt_len );
18611 
18612  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18613  }
18614  }
18615  }
18616  FCT_TEST_END();
18617 
18618 
18619  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240120_2)
18620  {
18621  unsigned char key_str[128];
18622  unsigned char src_str[128];
18623  unsigned char dst_str[257];
18624  unsigned char iv_str[128];
18625  unsigned char add_str[128];
18626  unsigned char tag_str[128];
18627  unsigned char output[128];
18628  gcm_context ctx;
18629  unsigned int key_len;
18630  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
18631  int ret;
18632 
18633  memset(key_str, 0x00, 128);
18634  memset(src_str, 0x00, 128);
18635  memset(dst_str, 0x00, 257);
18636  memset(iv_str, 0x00, 128);
18637  memset(add_str, 0x00, 128);
18638  memset(tag_str, 0x00, 128);
18639  memset(output, 0x00, 128);
18640 
18641  key_len = unhexify( key_str, "cd5c1e90d78213155c51767c52c290b3d657db8414ee0a7604a2ec7b48105667" );
18642  pt_len = unhexify( src_str, "8e987693da0fb77b6d1282eebd3a03e05d9955ff81929b1a2c721574862a067ddee392c7ece52ca1451f3e6e321d7208882d97b4149af6d78d65c054e1bfcdfa62bd2202de32dea8363f8d7f041891ce281840f3cd906ab46ca748e5b3b11890b4014bf0271c9427c874097782d1c13dbb40e78fc8276fc134f3c29923a43a01" );
18643  iv_len = unhexify( iv_str, "4e022d8d86efbd347e8cbab7e979771f" );
18644  add_len = unhexify( add_str, "" );
18645  unhexify( tag_str, "e7df79af0aef011299c3b882e3a45b" );
18646 
18647  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18648  if( 0 == 0 )
18649  {
18650  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18651 
18652  if( strcmp( "FAIL", "3b20473d9b5018d089e7f74d3fef22ec2805948a9e07689831973c704a6d8db4d090af88d696ab8c3aae9740a2bbd7f03e0b18b2b591e59c335c1043a2578a89b1a9f20fd0dd53f12e00e9bfdb27de8caac772bbfc4de9e4a255a5d1b04e59625a87b8279babe613def58d890d5502abf2f709aab625dcc20c58772832c7bbab" ) == 0 )
18653  {
18654  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18655  }
18656  else
18657  {
18658  hexify( dst_str, output, pt_len );
18659 
18660  fct_chk( strcmp( (char *) dst_str, "3b20473d9b5018d089e7f74d3fef22ec2805948a9e07689831973c704a6d8db4d090af88d696ab8c3aae9740a2bbd7f03e0b18b2b591e59c335c1043a2578a89b1a9f20fd0dd53f12e00e9bfdb27de8caac772bbfc4de9e4a255a5d1b04e59625a87b8279babe613def58d890d5502abf2f709aab625dcc20c58772832c7bbab" ) == 0 );
18661  }
18662  }
18663  }
18664  FCT_TEST_END();
18665 
18666 
18667  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240112_0)
18668  {
18669  unsigned char key_str[128];
18670  unsigned char src_str[128];
18671  unsigned char dst_str[257];
18672  unsigned char iv_str[128];
18673  unsigned char add_str[128];
18674  unsigned char tag_str[128];
18675  unsigned char output[128];
18676  gcm_context ctx;
18677  unsigned int key_len;
18678  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
18679  int ret;
18680 
18681  memset(key_str, 0x00, 128);
18682  memset(src_str, 0x00, 128);
18683  memset(dst_str, 0x00, 257);
18684  memset(iv_str, 0x00, 128);
18685  memset(add_str, 0x00, 128);
18686  memset(tag_str, 0x00, 128);
18687  memset(output, 0x00, 128);
18688 
18689  key_len = unhexify( key_str, "6e3dfc07003bb6a2d82bd5263b2832f47db4e73279266c7a9ea21f4f18eddf83" );
18690  pt_len = unhexify( src_str, "a960da222af9d4da5797e6957d59b00f6d3893599c70e95c0984b56eb3329b191703c2532f3288b15ebf655b9b5ee4617484e5ac9c39bb06731d03ebe4fef9495d003b0ed694cf540b4dc759d32629e55512680badd81234bd71ffd55fcb5e6a85031c1dc31ee1ed198939582d8336c905717cc87101dcfcf9d833fac815c8ea" );
18691  iv_len = unhexify( iv_str, "7c0f49fb54f5e68c84e81add009284e6" );
18692  add_len = unhexify( add_str, "" );
18693  unhexify( tag_str, "b2ec0f3da02a9eb3132fb4ebe3b8" );
18694 
18695  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18696  if( 0 == 0 )
18697  {
18698  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18699 
18700  if( strcmp( "FAIL", "a40b6f70f0572fe0bc70d83368e7c154f7dbd501f52501630a2e523d18e216e07368521f6040d806299397722b99bcf7f85d36b8bed934b49aa1fa76d38783e6a2e392d6d0786d467f7bc894a739ecf94f0fe884a9c391154f8326bf31ea5242a18aa263d04da4b63b11de23b42d3e10a2d5460cb32700cdf50a0d89165ba22a" ) == 0 )
18701  {
18702  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18703  }
18704  else
18705  {
18706  hexify( dst_str, output, pt_len );
18707 
18708  fct_chk( strcmp( (char *) dst_str, "a40b6f70f0572fe0bc70d83368e7c154f7dbd501f52501630a2e523d18e216e07368521f6040d806299397722b99bcf7f85d36b8bed934b49aa1fa76d38783e6a2e392d6d0786d467f7bc894a739ecf94f0fe884a9c391154f8326bf31ea5242a18aa263d04da4b63b11de23b42d3e10a2d5460cb32700cdf50a0d89165ba22a" ) == 0 );
18709  }
18710  }
18711  }
18712  FCT_TEST_END();
18713 
18714 
18715  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240112_1)
18716  {
18717  unsigned char key_str[128];
18718  unsigned char src_str[128];
18719  unsigned char dst_str[257];
18720  unsigned char iv_str[128];
18721  unsigned char add_str[128];
18722  unsigned char tag_str[128];
18723  unsigned char output[128];
18724  gcm_context ctx;
18725  unsigned int key_len;
18726  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
18727  int ret;
18728 
18729  memset(key_str, 0x00, 128);
18730  memset(src_str, 0x00, 128);
18731  memset(dst_str, 0x00, 257);
18732  memset(iv_str, 0x00, 128);
18733  memset(add_str, 0x00, 128);
18734  memset(tag_str, 0x00, 128);
18735  memset(output, 0x00, 128);
18736 
18737  key_len = unhexify( key_str, "4103b1ddff87a508a219c808a04ad4750668688f4c2ee75b92d28d70b98a2c94" );
18738  pt_len = unhexify( src_str, "a00a196193ff07006b7df524824bd0971d63f447a3a7bb1b75c1e2d11789482c115cff677b54948d36dc4de34200bce97be0101d88cee39b177857dd5da3cb0d2f9d6e1150f72a3bd655e0bace1d25a657ba9a7f8dff082b4460432075afb20173da22b49beeb6a030d72ba07869ff4389fc1c28d87018d7c1a9829c21932197" );
18739  iv_len = unhexify( iv_str, "5cea906737518c2cb901016e30206276" );
18740  add_len = unhexify( add_str, "" );
18741  unhexify( tag_str, "3a3a771dd5f31c977e154ef5c73a" );
18742 
18743  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18744  if( 0 == 0 )
18745  {
18746  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18747 
18748  if( strcmp( "FAIL", "FAIL" ) == 0 )
18749  {
18750  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18751  }
18752  else
18753  {
18754  hexify( dst_str, output, pt_len );
18755 
18756  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18757  }
18758  }
18759  }
18760  FCT_TEST_END();
18761 
18762 
18763  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240112_2)
18764  {
18765  unsigned char key_str[128];
18766  unsigned char src_str[128];
18767  unsigned char dst_str[257];
18768  unsigned char iv_str[128];
18769  unsigned char add_str[128];
18770  unsigned char tag_str[128];
18771  unsigned char output[128];
18772  gcm_context ctx;
18773  unsigned int key_len;
18774  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
18775  int ret;
18776 
18777  memset(key_str, 0x00, 128);
18778  memset(src_str, 0x00, 128);
18779  memset(dst_str, 0x00, 257);
18780  memset(iv_str, 0x00, 128);
18781  memset(add_str, 0x00, 128);
18782  memset(tag_str, 0x00, 128);
18783  memset(output, 0x00, 128);
18784 
18785  key_len = unhexify( key_str, "cd8c2f0c330d5db316dae7a16b57d681ca058864f7bd60f3d0de174442283f77" );
18786  pt_len = unhexify( src_str, "e2a5ad295d35031535bf13c2993bd0b292e8a9465b9dab738e59ba03670248a1ecc92b38a55bae34729162271cc1572c35fcccb27417b48dfcbff852a7a8845cc829a4461061b558ac8b5930a5c6491ffba04a9d0dff220b3cd5e4fc2e0f3db3b2ddd90328f2cad819573a7856299620b02f5ee0267f3b56981afbf1b7d9e3e1" );
18787  iv_len = unhexify( iv_str, "387ee8c1e7f047e94d06d0322eec02fc" );
18788  add_len = unhexify( add_str, "" );
18789  unhexify( tag_str, "62356850d12b54e39872357cfa03" );
18790 
18791  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18792  if( 0 == 0 )
18793  {
18794  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18795 
18796  if( strcmp( "FAIL", "17b7f6bdfc1993c56dd9bd674cc276a55a46fdd9fd5fe435b9e4b7ebc7052a9dc76a99e4e43aba7d486603189c90d10a21ad3722c86bf5bc856a0f930ff5bca65be708b76bb8a29105da67f31eebcec81f28aaf526d2f8f0feac393a24959dcd612e2b93b4463f61957d2b3046bcdf855e346601e4c7760c0ca618ee7bf55381" ) == 0 )
18797  {
18798  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18799  }
18800  else
18801  {
18802  hexify( dst_str, output, pt_len );
18803 
18804  fct_chk( strcmp( (char *) dst_str, "17b7f6bdfc1993c56dd9bd674cc276a55a46fdd9fd5fe435b9e4b7ebc7052a9dc76a99e4e43aba7d486603189c90d10a21ad3722c86bf5bc856a0f930ff5bca65be708b76bb8a29105da67f31eebcec81f28aaf526d2f8f0feac393a24959dcd612e2b93b4463f61957d2b3046bcdf855e346601e4c7760c0ca618ee7bf55381" ) == 0 );
18805  }
18806  }
18807  }
18808  FCT_TEST_END();
18809 
18810 
18811  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240104_0)
18812  {
18813  unsigned char key_str[128];
18814  unsigned char src_str[128];
18815  unsigned char dst_str[257];
18816  unsigned char iv_str[128];
18817  unsigned char add_str[128];
18818  unsigned char tag_str[128];
18819  unsigned char output[128];
18820  gcm_context ctx;
18821  unsigned int key_len;
18822  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
18823  int ret;
18824 
18825  memset(key_str, 0x00, 128);
18826  memset(src_str, 0x00, 128);
18827  memset(dst_str, 0x00, 257);
18828  memset(iv_str, 0x00, 128);
18829  memset(add_str, 0x00, 128);
18830  memset(tag_str, 0x00, 128);
18831  memset(output, 0x00, 128);
18832 
18833  key_len = unhexify( key_str, "7e19e400872eed721d560202cd757d3eb99729496b6e3a6d38dd8afe1066045a" );
18834  pt_len = unhexify( src_str, "3fb9abc7aba654dfb174e8899c17db222ffbb387b7260fc6f015b54f1cd74284c516e21aae3b72338e5e8dc643cfafca0678f5bda3a7539f1612dddb04366031b5a3eda55f3232c1b176cc9be7cc07e0ebca674a272224929c401a2530efc6d4eed0087b544b12d172a01bc8340d9c2a2ebcb5af8b07d96073a879fda140c196" );
18835  iv_len = unhexify( iv_str, "d2b277f78e98f1fa16f977ce72ee22a7" );
18836  add_len = unhexify( add_str, "" );
18837  unhexify( tag_str, "4c81c044101f458fdfac9ca3b9" );
18838 
18839  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18840  if( 0 == 0 )
18841  {
18842  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18843 
18844  if( strcmp( "FAIL", "FAIL" ) == 0 )
18845  {
18846  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18847  }
18848  else
18849  {
18850  hexify( dst_str, output, pt_len );
18851 
18852  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18853  }
18854  }
18855  }
18856  FCT_TEST_END();
18857 
18858 
18859  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240104_1)
18860  {
18861  unsigned char key_str[128];
18862  unsigned char src_str[128];
18863  unsigned char dst_str[257];
18864  unsigned char iv_str[128];
18865  unsigned char add_str[128];
18866  unsigned char tag_str[128];
18867  unsigned char output[128];
18868  gcm_context ctx;
18869  unsigned int key_len;
18870  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
18871  int ret;
18872 
18873  memset(key_str, 0x00, 128);
18874  memset(src_str, 0x00, 128);
18875  memset(dst_str, 0x00, 257);
18876  memset(iv_str, 0x00, 128);
18877  memset(add_str, 0x00, 128);
18878  memset(tag_str, 0x00, 128);
18879  memset(output, 0x00, 128);
18880 
18881  key_len = unhexify( key_str, "d0653934a16fd36c27d54488a1829302b931bed6e26ca26047242b85b50bfb61" );
18882  pt_len = unhexify( src_str, "c02347e1add9178d830d8baaad9aeee37e958bedf2cc846e2561fe8c83481d0a8a85911e7f1f6e444b28f30bd96c13c390e80f616feb6844ee6fa486543a2e3f38c138f45b4405e3fb331b64648219aaf1d574be948ccfca6afc18d12488db19c35b05601e47c0af5d49a93a5dd4420f38585c1eb033e173376fa390d3f948df" );
18883  iv_len = unhexify( iv_str, "94886a1845aebba5ed6b86f580be47f9" );
18884  add_len = unhexify( add_str, "" );
18885  unhexify( tag_str, "4be34ff42085ef4443c8b6042d" );
18886 
18887  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18888  if( 0 == 0 )
18889  {
18890  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18891 
18892  if( strcmp( "FAIL", "FAIL" ) == 0 )
18893  {
18894  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18895  }
18896  else
18897  {
18898  hexify( dst_str, output, pt_len );
18899 
18900  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18901  }
18902  }
18903  }
18904  FCT_TEST_END();
18905 
18906 
18907  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240104_2)
18908  {
18909  unsigned char key_str[128];
18910  unsigned char src_str[128];
18911  unsigned char dst_str[257];
18912  unsigned char iv_str[128];
18913  unsigned char add_str[128];
18914  unsigned char tag_str[128];
18915  unsigned char output[128];
18916  gcm_context ctx;
18917  unsigned int key_len;
18918  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
18919  int ret;
18920 
18921  memset(key_str, 0x00, 128);
18922  memset(src_str, 0x00, 128);
18923  memset(dst_str, 0x00, 257);
18924  memset(iv_str, 0x00, 128);
18925  memset(add_str, 0x00, 128);
18926  memset(tag_str, 0x00, 128);
18927  memset(output, 0x00, 128);
18928 
18929  key_len = unhexify( key_str, "d0f0ccb88c7cec9496f26a59ddc67dc59ebe49ae3dd89ef3be008598727e214c" );
18930  pt_len = unhexify( src_str, "7845e155f4f28021291e7c814a1ace8f42b239990831aa82758fc1e376cace0b6f668f7f2f224dede1ef5b1df7ae74b2c01483701044acbbb72a9216eec6b7ef0190f114b3c73c6985c4653f11601c774d10b7f9df1f1e1f3ff4fafa20d6525edb37d9e5acfafe6d3468ee068d407fdb56dc718c98425926831253978d727854" );
18931  iv_len = unhexify( iv_str, "e5ca84b907ac761a5e68a9080da0a88a" );
18932  add_len = unhexify( add_str, "" );
18933  unhexify( tag_str, "c8f78e4139dd3eaf2baef8aafb" );
18934 
18935  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18936  if( 0 == 0 )
18937  {
18938  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18939 
18940  if( strcmp( "FAIL", "0cc3ede50b0d3fb9ada11300a3239a383c98f968ad65266d57a195bb18d3e568fe6cabba258da4bee9e923c7c838e06dc887a6c49cc1453ea6a227c6a83e651a8742e0316cad5efc93739393e3603446b5c920a206db1434adbb8ebde4d1a7a8699c7f6c61b2d57c9709b564338423b4f526d6c157647a6c45da9dd521061f05" ) == 0 )
18941  {
18942  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18943  }
18944  else
18945  {
18946  hexify( dst_str, output, pt_len );
18947 
18948  fct_chk( strcmp( (char *) dst_str, "0cc3ede50b0d3fb9ada11300a3239a383c98f968ad65266d57a195bb18d3e568fe6cabba258da4bee9e923c7c838e06dc887a6c49cc1453ea6a227c6a83e651a8742e0316cad5efc93739393e3603446b5c920a206db1434adbb8ebde4d1a7a8699c7f6c61b2d57c9709b564338423b4f526d6c157647a6c45da9dd521061f05" ) == 0 );
18949  }
18950  }
18951  }
18952  FCT_TEST_END();
18953 
18954 
18955  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024096_0)
18956  {
18957  unsigned char key_str[128];
18958  unsigned char src_str[128];
18959  unsigned char dst_str[257];
18960  unsigned char iv_str[128];
18961  unsigned char add_str[128];
18962  unsigned char tag_str[128];
18963  unsigned char output[128];
18964  gcm_context ctx;
18965  unsigned int key_len;
18966  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
18967  int ret;
18968 
18969  memset(key_str, 0x00, 128);
18970  memset(src_str, 0x00, 128);
18971  memset(dst_str, 0x00, 257);
18972  memset(iv_str, 0x00, 128);
18973  memset(add_str, 0x00, 128);
18974  memset(tag_str, 0x00, 128);
18975  memset(output, 0x00, 128);
18976 
18977  key_len = unhexify( key_str, "e35dcea17cbf391491ae5ba6056d0dd13b348183474dd4b614742751bdebfc32" );
18978  pt_len = unhexify( src_str, "5213542beb044910d7fdeec8bb89de93f350760e493286eaef1140485380d429f74a4279c1842a5c64f3ca3381cb5dbb0621de48821bded650cb59703e0ca88f4e9c3d15875f9dc87d85ba7e4bae9986ef8c203fce6f0ce52c28e3a93befb4cc4ba3d963d2283cd30f9bf6ab99d92f2f4f3aff0b022f1751b89d43ea10bbb28a" );
18979  iv_len = unhexify( iv_str, "fa549b33b5a43d85f012929a4816297a" );
18980  add_len = unhexify( add_str, "" );
18981  unhexify( tag_str, "afa61e843cee615c97de42a7" );
18982 
18983  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
18984  if( 0 == 0 )
18985  {
18986  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
18987 
18988  if( strcmp( "FAIL", "FAIL" ) == 0 )
18989  {
18990  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
18991  }
18992  else
18993  {
18994  hexify( dst_str, output, pt_len );
18995 
18996  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
18997  }
18998  }
18999  }
19000  FCT_TEST_END();
19001 
19002 
19003  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024096_1)
19004  {
19005  unsigned char key_str[128];
19006  unsigned char src_str[128];
19007  unsigned char dst_str[257];
19008  unsigned char iv_str[128];
19009  unsigned char add_str[128];
19010  unsigned char tag_str[128];
19011  unsigned char output[128];
19012  gcm_context ctx;
19013  unsigned int key_len;
19014  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
19015  int ret;
19016 
19017  memset(key_str, 0x00, 128);
19018  memset(src_str, 0x00, 128);
19019  memset(dst_str, 0x00, 257);
19020  memset(iv_str, 0x00, 128);
19021  memset(add_str, 0x00, 128);
19022  memset(tag_str, 0x00, 128);
19023  memset(output, 0x00, 128);
19024 
19025  key_len = unhexify( key_str, "844c50ddc0ac1d9364b21003287d6ae6360d12bbb17a85351362420ee4ca588e" );
19026  pt_len = unhexify( src_str, "3a3bf4ccaf05f7c02f5e158dd2c5cb08c6aed4b1ba404a6d8ef9a0737fe2f350b3e22188fc330ea63e35df82f996e3cf94d331c4246cdb25bb2c409762e05ddc21f337edee51b64f1766ad18f520b3f34735b24278d9d647c533a743e0c1e9c81e9dee975cdc47e8582113fd250ef59353605b64acb7c025a97854c1a5c03237" );
19027  iv_len = unhexify( iv_str, "2f8512bb7e214db774a217a4615139e1" );
19028  add_len = unhexify( add_str, "" );
19029  unhexify( tag_str, "f1da1cebe00d80eb4e025feb" );
19030 
19031  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19032  if( 0 == 0 )
19033  {
19034  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19035 
19036  if( strcmp( "FAIL", "FAIL" ) == 0 )
19037  {
19038  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19039  }
19040  else
19041  {
19042  hexify( dst_str, output, pt_len );
19043 
19044  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19045  }
19046  }
19047  }
19048  FCT_TEST_END();
19049 
19050 
19051  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024096_2)
19052  {
19053  unsigned char key_str[128];
19054  unsigned char src_str[128];
19055  unsigned char dst_str[257];
19056  unsigned char iv_str[128];
19057  unsigned char add_str[128];
19058  unsigned char tag_str[128];
19059  unsigned char output[128];
19060  gcm_context ctx;
19061  unsigned int key_len;
19062  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
19063  int ret;
19064 
19065  memset(key_str, 0x00, 128);
19066  memset(src_str, 0x00, 128);
19067  memset(dst_str, 0x00, 257);
19068  memset(iv_str, 0x00, 128);
19069  memset(add_str, 0x00, 128);
19070  memset(tag_str, 0x00, 128);
19071  memset(output, 0x00, 128);
19072 
19073  key_len = unhexify( key_str, "2aae1aa047a20ed2d6d8336d923864cee9404f924031ae327fbfe2d293e1d93c" );
19074  pt_len = unhexify( src_str, "8e5b6b9e4e7d01de9a919dd33c0c1eb94dcfebf28847c754c62c1c00642d9e96f15b5d28ad103ff6969be750aadfd02fc146935562c83ec459a932a2fd5fda32eb851e6cff33335abd5c2434ae4f5524d6bc74a38094ced360f4606a1a17096ff06604952c8ca94a9a6dc4a251e13b0e0c54bd8a6dff5f397a1eb1cf186fa518" );
19075  iv_len = unhexify( iv_str, "3da9af3567d70553ca3a9636f0b26470" );
19076  add_len = unhexify( add_str, "" );
19077  unhexify( tag_str, "e1026b3d15d261b2fb47632e" );
19078 
19079  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19080  if( 0 == 0 )
19081  {
19082  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19083 
19084  if( strcmp( "FAIL", "58c52ea9f3b162511160eed1a68b6f52b3c4f5834af728de97a3d9e4ba337b29aad12636003cf5be9ffbeae0f383f7cf32f645a8f6fc5cdc1cde91c625c69a92bc434ed671e52a0044a48f3fce55cae49a7d065c2a72603a7efe58b5a7b18ac500d1a51420e820357e7a439b1c02198ebe3d4e62d5573a3aa5f40900a21e3b41" ) == 0 )
19085  {
19086  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19087  }
19088  else
19089  {
19090  hexify( dst_str, output, pt_len );
19091 
19092  fct_chk( strcmp( (char *) dst_str, "58c52ea9f3b162511160eed1a68b6f52b3c4f5834af728de97a3d9e4ba337b29aad12636003cf5be9ffbeae0f383f7cf32f645a8f6fc5cdc1cde91c625c69a92bc434ed671e52a0044a48f3fce55cae49a7d065c2a72603a7efe58b5a7b18ac500d1a51420e820357e7a439b1c02198ebe3d4e62d5573a3aa5f40900a21e3b41" ) == 0 );
19093  }
19094  }
19095  }
19096  FCT_TEST_END();
19097 
19098 
19099  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024064_0)
19100  {
19101  unsigned char key_str[128];
19102  unsigned char src_str[128];
19103  unsigned char dst_str[257];
19104  unsigned char iv_str[128];
19105  unsigned char add_str[128];
19106  unsigned char tag_str[128];
19107  unsigned char output[128];
19108  gcm_context ctx;
19109  unsigned int key_len;
19110  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
19111  int ret;
19112 
19113  memset(key_str, 0x00, 128);
19114  memset(src_str, 0x00, 128);
19115  memset(dst_str, 0x00, 257);
19116  memset(iv_str, 0x00, 128);
19117  memset(add_str, 0x00, 128);
19118  memset(tag_str, 0x00, 128);
19119  memset(output, 0x00, 128);
19120 
19121  key_len = unhexify( key_str, "f3d69208cb0d27474e9a231cd46eac7c1574fff950c48bbd1ba03fad16f563df" );
19122  pt_len = unhexify( src_str, "0d1f06eef5e8f2c81d1a73bb1dca93c22cfb6e40e9948bc75b0d84830fb9216330424f580b89050c3fb3f620eca8f9fd09fb86d2e8b3a0869c6022d8a705fc280d66fd16d3aba7395d6be4bed44145d51d42d56285f3675726d62d94c081364a6d440511de83a613c598b03078e2ec7648c6302defbbea66aafd33e1a4b1686c" );
19123  iv_len = unhexify( iv_str, "b957f05921d21f2192f587768dc12b4f" );
19124  add_len = unhexify( add_str, "" );
19125  unhexify( tag_str, "322374fbb192abbc" );
19126 
19127  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19128  if( 0 == 0 )
19129  {
19130  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19131 
19132  if( strcmp( "FAIL", "FAIL" ) == 0 )
19133  {
19134  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19135  }
19136  else
19137  {
19138  hexify( dst_str, output, pt_len );
19139 
19140  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19141  }
19142  }
19143  }
19144  FCT_TEST_END();
19145 
19146 
19147  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024064_1)
19148  {
19149  unsigned char key_str[128];
19150  unsigned char src_str[128];
19151  unsigned char dst_str[257];
19152  unsigned char iv_str[128];
19153  unsigned char add_str[128];
19154  unsigned char tag_str[128];
19155  unsigned char output[128];
19156  gcm_context ctx;
19157  unsigned int key_len;
19158  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
19159  int ret;
19160 
19161  memset(key_str, 0x00, 128);
19162  memset(src_str, 0x00, 128);
19163  memset(dst_str, 0x00, 257);
19164  memset(iv_str, 0x00, 128);
19165  memset(add_str, 0x00, 128);
19166  memset(tag_str, 0x00, 128);
19167  memset(output, 0x00, 128);
19168 
19169  key_len = unhexify( key_str, "cb2cdeb17fa6bcb006c7fc60858a12a411804464458db351957e8caf42f1ee6c" );
19170  pt_len = unhexify( src_str, "296504131354b2c1928982f12d408ba2377f2d4bbe87e4c69f92a15bf6003910a43bda6c8929df66b3ab1d202a5258cad199f32f36cc30d2dc06199c2a52f7ccadad1fce50123c5f8434dec57cc60cc780263d7aace8f59cc8a6c54bddbaded3adb12ae2ee0bacf6a8da635ff85b51a4e8a1b3dc404863b90059de4ad0f158dd" );
19171  iv_len = unhexify( iv_str, "31bd7c971a6d330b566567ab19590545" );
19172  add_len = unhexify( add_str, "" );
19173  unhexify( tag_str, "efc5a1acf433aaa3" );
19174 
19175  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19176  if( 0 == 0 )
19177  {
19178  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19179 
19180  if( strcmp( "FAIL", "FAIL" ) == 0 )
19181  {
19182  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19183  }
19184  else
19185  {
19186  hexify( dst_str, output, pt_len );
19187 
19188  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19189  }
19190  }
19191  }
19192  FCT_TEST_END();
19193 
19194 
19195  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024064_2)
19196  {
19197  unsigned char key_str[128];
19198  unsigned char src_str[128];
19199  unsigned char dst_str[257];
19200  unsigned char iv_str[128];
19201  unsigned char add_str[128];
19202  unsigned char tag_str[128];
19203  unsigned char output[128];
19204  gcm_context ctx;
19205  unsigned int key_len;
19206  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
19207  int ret;
19208 
19209  memset(key_str, 0x00, 128);
19210  memset(src_str, 0x00, 128);
19211  memset(dst_str, 0x00, 257);
19212  memset(iv_str, 0x00, 128);
19213  memset(add_str, 0x00, 128);
19214  memset(tag_str, 0x00, 128);
19215  memset(output, 0x00, 128);
19216 
19217  key_len = unhexify( key_str, "f94170790fadab3240df568197f9d6f6855afaed8d07eceeaa2380121872529f" );
19218  pt_len = unhexify( src_str, "ed231b78db082f652bc6310c396993b52de804a82464fa3fac602a1286535f59c67fc2b1b420c7321eb42b971edde24cd4cb9e75c843f2ac6fb8ecdad612d2e5049cf39327aa7a8d43ec821161c385f3fdc92284a764a5d1cbae886f07f93017f83a105bb7c3cc4fc51e2781516a2471b65c940ddae6b550ad37b35f53d7cc64" );
19219  iv_len = unhexify( iv_str, "2f9c0647a4af7f61ced45f28d45c43f1" );
19220  add_len = unhexify( add_str, "" );
19221  unhexify( tag_str, "ab74877a0b223e1c" );
19222 
19223  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19224  if( 0 == 0 )
19225  {
19226  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19227 
19228  if( strcmp( "FAIL", "1cb5ed0c10cee98ff8ecfa5a1b6592391bbd9f9b1dc1ff351e0af23920d546b5e27d62b94daabd32f7f96a2632dc9fd7c19bf55f3b9b7cd492e76f4d6b0f5b437c155c14a75e65bfc4120bef186da05e06a2fd3696f210292ee422ddbce6e63d99ee766b68363139438733c5e567177f72e52ef2df6a7dd33fc0376d12ec3005" ) == 0 )
19229  {
19230  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19231  }
19232  else
19233  {
19234  hexify( dst_str, output, pt_len );
19235 
19236  fct_chk( strcmp( (char *) dst_str, "1cb5ed0c10cee98ff8ecfa5a1b6592391bbd9f9b1dc1ff351e0af23920d546b5e27d62b94daabd32f7f96a2632dc9fd7c19bf55f3b9b7cd492e76f4d6b0f5b437c155c14a75e65bfc4120bef186da05e06a2fd3696f210292ee422ddbce6e63d99ee766b68363139438733c5e567177f72e52ef2df6a7dd33fc0376d12ec3005" ) == 0 );
19237  }
19238  }
19239  }
19240  FCT_TEST_END();
19241 
19242 
19243  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024032_0)
19244  {
19245  unsigned char key_str[128];
19246  unsigned char src_str[128];
19247  unsigned char dst_str[257];
19248  unsigned char iv_str[128];
19249  unsigned char add_str[128];
19250  unsigned char tag_str[128];
19251  unsigned char output[128];
19252  gcm_context ctx;
19253  unsigned int key_len;
19254  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
19255  int ret;
19256 
19257  memset(key_str, 0x00, 128);
19258  memset(src_str, 0x00, 128);
19259  memset(dst_str, 0x00, 257);
19260  memset(iv_str, 0x00, 128);
19261  memset(add_str, 0x00, 128);
19262  memset(tag_str, 0x00, 128);
19263  memset(output, 0x00, 128);
19264 
19265  key_len = unhexify( key_str, "797c0091ff8787fe7cd0427c02922620e7f6fb71c52ddcc03a9f25c89ba33490" );
19266  pt_len = unhexify( src_str, "2d3efc8900315c3691a8e3c9de3319d4deaf538fcf41aa0e295b861d0ac85baf56d149a6437747dd6976f44016e012b88de542fb8e5b9e4ad10c19deec4b7c0b69bc1b2e33d44a981ded66127dea354b072010b8dc24b85ed2ffeea3b9c0e931619dbbf22677691f0d54fc03eaa162e0ab0d760ad41021f67057c0d6ac19ca8f" );
19267  iv_len = unhexify( iv_str, "69d81c73008a6827a692fa636fbab8bb" );
19268  add_len = unhexify( add_str, "" );
19269  unhexify( tag_str, "be2dda5c" );
19270 
19271  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19272  if( 0 == 0 )
19273  {
19274  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19275 
19276  if( strcmp( "FAIL", "FAIL" ) == 0 )
19277  {
19278  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19279  }
19280  else
19281  {
19282  hexify( dst_str, output, pt_len );
19283 
19284  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19285  }
19286  }
19287  }
19288  FCT_TEST_END();
19289 
19290 
19291  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024032_1)
19292  {
19293  unsigned char key_str[128];
19294  unsigned char src_str[128];
19295  unsigned char dst_str[257];
19296  unsigned char iv_str[128];
19297  unsigned char add_str[128];
19298  unsigned char tag_str[128];
19299  unsigned char output[128];
19300  gcm_context ctx;
19301  unsigned int key_len;
19302  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
19303  int ret;
19304 
19305  memset(key_str, 0x00, 128);
19306  memset(src_str, 0x00, 128);
19307  memset(dst_str, 0x00, 257);
19308  memset(iv_str, 0x00, 128);
19309  memset(add_str, 0x00, 128);
19310  memset(tag_str, 0x00, 128);
19311  memset(output, 0x00, 128);
19312 
19313  key_len = unhexify( key_str, "90ce1afb5500489b9edbad987f4009509c847b3e55cdf0c764ef2fb085e3d033" );
19314  pt_len = unhexify( src_str, "98482b54edce2bac1cd64d44917dcf117ebfbfe26ad17a9b263447028304f1cf5a69559c05b5d833420f4fddb6e308277d01eb4b3235f1c4b47d33d3899325b55e7be19d43187a5b1b1354ce02a529b3df1c13b4883902ae9fc565079dee825e705f3e580371e4fd86c3b0d31bae98adb529901f346ca07127314152b4370edd" );
19315  iv_len = unhexify( iv_str, "e119e166471ecf44bc3a070639619931" );
19316  add_len = unhexify( add_str, "" );
19317  unhexify( tag_str, "b2f54b3a" );
19318 
19319  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19320  if( 0 == 0 )
19321  {
19322  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19323 
19324  if( strcmp( "FAIL", "FAIL" ) == 0 )
19325  {
19326  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19327  }
19328  else
19329  {
19330  hexify( dst_str, output, pt_len );
19331 
19332  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19333  }
19334  }
19335  }
19336  FCT_TEST_END();
19337 
19338 
19339  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024032_2)
19340  {
19341  unsigned char key_str[128];
19342  unsigned char src_str[128];
19343  unsigned char dst_str[257];
19344  unsigned char iv_str[128];
19345  unsigned char add_str[128];
19346  unsigned char tag_str[128];
19347  unsigned char output[128];
19348  gcm_context ctx;
19349  unsigned int key_len;
19350  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
19351  int ret;
19352 
19353  memset(key_str, 0x00, 128);
19354  memset(src_str, 0x00, 128);
19355  memset(dst_str, 0x00, 257);
19356  memset(iv_str, 0x00, 128);
19357  memset(add_str, 0x00, 128);
19358  memset(tag_str, 0x00, 128);
19359  memset(output, 0x00, 128);
19360 
19361  key_len = unhexify( key_str, "29264a90f114a800c0fc3247b3bda00981a12a8f85cf3a19ea4c7ffdd005f4bb" );
19362  pt_len = unhexify( src_str, "587c8e53ab5ae8c31e16160b4a41d88798e27f4ad61c573c023c62d4dbb3952eef5026ad7b453fa9e0694347ab8fe50a6cf20da566202b81e325cee9c07ab2d4d53ed45b3ec2d2135936515f8a24f2a8116807dce9df3c44edf64c32647145152ff241d9e018e4101e400af070192dc3b498b5a213d265b4cfc8c8d4d7deccb5" );
19363  iv_len = unhexify( iv_str, "cf296aa43cb7b328e09c8975e067404e" );
19364  add_len = unhexify( add_str, "" );
19365  unhexify( tag_str, "56015c1e" );
19366 
19367  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19368  if( 0 == 0 )
19369  {
19370  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19371 
19372  if( strcmp( "FAIL", "FAIL" ) == 0 )
19373  {
19374  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19375  }
19376  else
19377  {
19378  hexify( dst_str, output, pt_len );
19379 
19380  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19381  }
19382  }
19383  }
19384  FCT_TEST_END();
19385 
19386 
19387  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024128_0)
19388  {
19389  unsigned char key_str[128];
19390  unsigned char src_str[128];
19391  unsigned char dst_str[257];
19392  unsigned char iv_str[128];
19393  unsigned char add_str[128];
19394  unsigned char tag_str[128];
19395  unsigned char output[128];
19396  gcm_context ctx;
19397  unsigned int key_len;
19398  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
19399  int ret;
19400 
19401  memset(key_str, 0x00, 128);
19402  memset(src_str, 0x00, 128);
19403  memset(dst_str, 0x00, 257);
19404  memset(iv_str, 0x00, 128);
19405  memset(add_str, 0x00, 128);
19406  memset(tag_str, 0x00, 128);
19407  memset(output, 0x00, 128);
19408 
19409  key_len = unhexify( key_str, "84ff9a8772815b929d55f6052c0354cf3e02bcc8336fcfe5794952b4c45d5d96" );
19410  pt_len = unhexify( src_str, "a87de56d49725a1625baf12fd15931fe1a6783dce5d1e744eba108f45e0c105d8141dc027d0e33ad7efb6752b43729715e2f3e2c42ebdab4d5f72f886bd821c4372244699ddded99a63dbe7763a5a3bc21cbfc253cdc2514eba2a4f54e24dca7c207cb3f6ae80153d77fe0641f357d5a073dcd425c38deb77c45f27427345516" );
19411  iv_len = unhexify( iv_str, "5c044a66e488b853baf479f7dee2aadb" );
19412  add_len = unhexify( add_str, "00304e3d40cbc6d2bee0778462884f4ec047a8c74bb3dd7e100f2b9d0e529fd24730063986117b56ca876b208a3691425ac63afc3d504ccb499c76622eade09717023fcb7d956b01ce24a3e53cb5da472be3fcf5b278b5d9e377de22fab75bc74afa9670f5fe9691aa0ed77e43f6abc67a61ec409ec39fd66ac0307bf195f36f" );
19413  unhexify( tag_str, "72ddd9966ede9b684bc981cbb2113313" );
19414 
19415  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19416  if( 0 == 0 )
19417  {
19418  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19419 
19420  if( strcmp( "FAIL", "aadb8537309940422f67ca393aa6182d67fe7c52092538a15e98a4254f0a9087c7f10903d5e78078c2e55de914dec8b6b35cb720e3e55963c0ac9901e44b83a0e7c5b2d3f002aec0a4a08354febe47b2abb955f2a21107626ef0b8e1e099650812a6fecf36908fce2d078c2735cf7c2b970a309e5c6d6ff29c26a05720c57105" ) == 0 )
19421  {
19422  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19423  }
19424  else
19425  {
19426  hexify( dst_str, output, pt_len );
19427 
19428  fct_chk( strcmp( (char *) dst_str, "aadb8537309940422f67ca393aa6182d67fe7c52092538a15e98a4254f0a9087c7f10903d5e78078c2e55de914dec8b6b35cb720e3e55963c0ac9901e44b83a0e7c5b2d3f002aec0a4a08354febe47b2abb955f2a21107626ef0b8e1e099650812a6fecf36908fce2d078c2735cf7c2b970a309e5c6d6ff29c26a05720c57105" ) == 0 );
19429  }
19430  }
19431  }
19432  FCT_TEST_END();
19433 
19434 
19435  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024128_1)
19436  {
19437  unsigned char key_str[128];
19438  unsigned char src_str[128];
19439  unsigned char dst_str[257];
19440  unsigned char iv_str[128];
19441  unsigned char add_str[128];
19442  unsigned char tag_str[128];
19443  unsigned char output[128];
19444  gcm_context ctx;
19445  unsigned int key_len;
19446  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
19447  int ret;
19448 
19449  memset(key_str, 0x00, 128);
19450  memset(src_str, 0x00, 128);
19451  memset(dst_str, 0x00, 257);
19452  memset(iv_str, 0x00, 128);
19453  memset(add_str, 0x00, 128);
19454  memset(tag_str, 0x00, 128);
19455  memset(output, 0x00, 128);
19456 
19457  key_len = unhexify( key_str, "b5ca3991d0160b1729ae1a622dcf4b03b1f4ba86150bd66bf35cbbee9258af10" );
19458  pt_len = unhexify( src_str, "62aad5854a238f096bdde0711ac6f5763e7fea29db068ea8c911f17ba91e6d7807883e6fc5ba7db17af33da2b00973008a3425e65cc786ce1b97360019ee2cef74563d54752be436b905705b507c3d62689df4edf0356d26b693eb43d8a2a927a9f3866b7e0e19e84a90447bd6f47e31070fa7c2a71e3f78229ee19fa47e848f" );
19459  iv_len = unhexify( iv_str, "f8402184d1cc36df07b68ecb1ab42047" );
19460  add_len = unhexify( add_str, "d378cfd29758bcbd21e26a324239c42c992941b3ad68d9f2b3d2def3a051fd172ee882562970ef59798ff8d9eb5f724ff17626156f4cf5d93e41ffef6e525919af6194ea9bbb58c67563d3ffd90e5a6e2a3a33bd1fa3d55eff5dba7cd439d571f7e08014c4780e3d10904ef22b660897e78258da20b2600e88d71c35ecb6329a" );
19461  unhexify( tag_str, "9e8b59b4971130557aa84ec3ac7e4133" );
19462 
19463  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19464  if( 0 == 0 )
19465  {
19466  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19467 
19468  if( strcmp( "FAIL", "556dd32edc0af3c64186fe8c000ddad1516cd14721c93c228e379d4f87e32c79e734539cec930322048f34a2b34931c585d44f09966caf187ec4b9244c991a8a5f263e9da1d08d6086e52535afdb36c7662307521cbceb9ecb470a76970243723fbc1613b6ebbcae261ac2f1936e66ce29ec7350b2e6b2f73a910ade645154f7" ) == 0 )
19469  {
19470  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19471  }
19472  else
19473  {
19474  hexify( dst_str, output, pt_len );
19475 
19476  fct_chk( strcmp( (char *) dst_str, "556dd32edc0af3c64186fe8c000ddad1516cd14721c93c228e379d4f87e32c79e734539cec930322048f34a2b34931c585d44f09966caf187ec4b9244c991a8a5f263e9da1d08d6086e52535afdb36c7662307521cbceb9ecb470a76970243723fbc1613b6ebbcae261ac2f1936e66ce29ec7350b2e6b2f73a910ade645154f7" ) == 0 );
19477  }
19478  }
19479  }
19480  FCT_TEST_END();
19481 
19482 
19483  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024128_2)
19484  {
19485  unsigned char key_str[128];
19486  unsigned char src_str[128];
19487  unsigned char dst_str[257];
19488  unsigned char iv_str[128];
19489  unsigned char add_str[128];
19490  unsigned char tag_str[128];
19491  unsigned char output[128];
19492  gcm_context ctx;
19493  unsigned int key_len;
19494  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
19495  int ret;
19496 
19497  memset(key_str, 0x00, 128);
19498  memset(src_str, 0x00, 128);
19499  memset(dst_str, 0x00, 257);
19500  memset(iv_str, 0x00, 128);
19501  memset(add_str, 0x00, 128);
19502  memset(tag_str, 0x00, 128);
19503  memset(output, 0x00, 128);
19504 
19505  key_len = unhexify( key_str, "df867d1dd8a287821a54479cab6f88636d2aca30e1bf01a5dffc735e17590356" );
19506  pt_len = unhexify( src_str, "6517272cac85d7f38902bcb4b96a0c59c4bdc46bfefa6ebacd7f2fb1629b87ca91de2ffefc42ce3cfd34dcbf01b3f7cadcea3f99e6addf35d36c51f2ceb1f85c1f56a04ec9c9fff60cd7fc238674992183ea3de72ef778561b906202b7b83fe6562a0bca9c1e0a18638e8685b998b4192f5120435809ad6e93a0422d00725262" );
19507  iv_len = unhexify( iv_str, "35019826c51dd1ef07ff915d9ac4ea96" );
19508  add_len = unhexify( add_str, "0375ed93f287eefe414ab2968844bd10148860c528dbf571a77aa74f98cc669a7fc317adc9f7cf2d80dda29b19db635b30a044399f3665b6176ed669146d28f5ada03b3d32d53fe46575a8afcd37f20386d9e36f7e090b4fefadfab7f008e02f1b5022c0eeb81d03443a276eae48c038ed173631687d2450b913b02c97243edb" );
19509  unhexify( tag_str, "e49beb083a9b008ae97a17e3825692f0" );
19510 
19511  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19512  if( 0 == 0 )
19513  {
19514  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19515 
19516  if( strcmp( "FAIL", "723be39bc13adbc48c861b07753f64fac1ae28fc8933acba888b6538721df0a8b91c040a26522fe0dbb7335d8f63d209e89f7cde23afa9ca3c584b336d63a91e07fdd8808b14c3214c96a202e665bbaaa34248ff30348f3d79c9f16e66ad6c5903305acd887a89b6244eb7c2d96e18b13a686de935bf3821444ee20f48678be5" ) == 0 )
19517  {
19518  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19519  }
19520  else
19521  {
19522  hexify( dst_str, output, pt_len );
19523 
19524  fct_chk( strcmp( (char *) dst_str, "723be39bc13adbc48c861b07753f64fac1ae28fc8933acba888b6538721df0a8b91c040a26522fe0dbb7335d8f63d209e89f7cde23afa9ca3c584b336d63a91e07fdd8808b14c3214c96a202e665bbaaa34248ff30348f3d79c9f16e66ad6c5903305acd887a89b6244eb7c2d96e18b13a686de935bf3821444ee20f48678be5" ) == 0 );
19525  }
19526  }
19527  }
19528  FCT_TEST_END();
19529 
19530 
19531  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024120_0)
19532  {
19533  unsigned char key_str[128];
19534  unsigned char src_str[128];
19535  unsigned char dst_str[257];
19536  unsigned char iv_str[128];
19537  unsigned char add_str[128];
19538  unsigned char tag_str[128];
19539  unsigned char output[128];
19540  gcm_context ctx;
19541  unsigned int key_len;
19542  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
19543  int ret;
19544 
19545  memset(key_str, 0x00, 128);
19546  memset(src_str, 0x00, 128);
19547  memset(dst_str, 0x00, 257);
19548  memset(iv_str, 0x00, 128);
19549  memset(add_str, 0x00, 128);
19550  memset(tag_str, 0x00, 128);
19551  memset(output, 0x00, 128);
19552 
19553  key_len = unhexify( key_str, "0e8e9ce6294b7fbc534a96bdd060120976a6e08315d2ea73ac61d085cd462a44" );
19554  pt_len = unhexify( src_str, "9855f186b51358f0e2111c06bfaaeaec9bf95c55e246375c614fad9883d86c82a20c86538dc5f42a0ea69677d59a20c5112d15d2a8396f12096242ad5d7b838d16ee0679fc4017af75bc15e8ad2f77b0e802c864031cbfb0bacd95c828d1db4b7bab0713619e9e5e8fe6902aac7a9e6c42eb05f5b156f7e663ee43e6fdb62480" );
19555  iv_len = unhexify( iv_str, "4edc6be20f904b4789e5bee0a80a3fc8" );
19556  add_len = unhexify( add_str, "db28ce076b360816cd1e04b7729f8ab080e0a07f35204350f3bd056945aab8638c0e8311ab056f3e5debdbfbb03fae700770264faf73e0f3a05a5812aee84ab613c82f4a76da276250675f6a663f85e2c26d4f4a8666a7f4cedaffc1a7218dec11ca4e72b8b5d5b620d1efbd3d3b94a5ae0d118b9860dfd543b04c78d13a94c3" );
19557  unhexify( tag_str, "03cfe6c36c3f54b3188a6ef3866b84" );
19558 
19559  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19560  if( 0 == 0 )
19561  {
19562  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19563 
19564  if( strcmp( "FAIL", "e10142f852a0d680c983aad2b4609ccbd35ff61bb3eb66442aee6e01d4cc1cd70f45210acbd506395d6ca0cfebc195a196c94b94fc2afb9ffa3b1714653e07e048804746955e2070e1e96bff58f9bc56f3862aaa5fe23a6a57b5e764666ddec9e3e5a6af063f2c150889268619d0128b3b5562d27070e58e41aadd471d92d07e" ) == 0 )
19565  {
19566  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19567  }
19568  else
19569  {
19570  hexify( dst_str, output, pt_len );
19571 
19572  fct_chk( strcmp( (char *) dst_str, "e10142f852a0d680c983aad2b4609ccbd35ff61bb3eb66442aee6e01d4cc1cd70f45210acbd506395d6ca0cfebc195a196c94b94fc2afb9ffa3b1714653e07e048804746955e2070e1e96bff58f9bc56f3862aaa5fe23a6a57b5e764666ddec9e3e5a6af063f2c150889268619d0128b3b5562d27070e58e41aadd471d92d07e" ) == 0 );
19573  }
19574  }
19575  }
19576  FCT_TEST_END();
19577 
19578 
19579  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024120_1)
19580  {
19581  unsigned char key_str[128];
19582  unsigned char src_str[128];
19583  unsigned char dst_str[257];
19584  unsigned char iv_str[128];
19585  unsigned char add_str[128];
19586  unsigned char tag_str[128];
19587  unsigned char output[128];
19588  gcm_context ctx;
19589  unsigned int key_len;
19590  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
19591  int ret;
19592 
19593  memset(key_str, 0x00, 128);
19594  memset(src_str, 0x00, 128);
19595  memset(dst_str, 0x00, 257);
19596  memset(iv_str, 0x00, 128);
19597  memset(add_str, 0x00, 128);
19598  memset(tag_str, 0x00, 128);
19599  memset(output, 0x00, 128);
19600 
19601  key_len = unhexify( key_str, "886c77b80f5f3a21c01932685a540b23629f6d41d5574fc527227ed0bdf2e21b" );
19602  pt_len = unhexify( src_str, "53a17d7b69f607f08676d6f6dd4e8db08e01333a8355d8c87616e84cdf10ef5b041fc6ddc3f6a245c0f534c2b167064af82f45e4702a5e8dede59579fdecf6713353392433950c9b97c38d9ee515ac97d0970ccf03981954540088567a30941bb2cca08cbed680500f8342faa7aebbc6c143e2ea57ba6b4ac1fd975dcc5d0871" );
19603  iv_len = unhexify( iv_str, "5ec506edb1890a5a63b464490450d419" );
19604  add_len = unhexify( add_str, "05b8d820c9f439d7aeae5c7da0ee25fb0dad47cc3e6f3a47e8b984e856201546975f8214531fc3c2e504d2ac10fa49cb948596b9a8fab01b95c49d6f04d1589f93b77b899e803dd20e1f00a51c0b5953e85be639109b14b100e35ca26d84ea629964b0db8260dfa5a150a66261bf37e79de2ec49e9f1b082a7c58ecd3d39b6c9" );
19605  unhexify( tag_str, "ffdf56e1c1a7252b88422787536484" );
19606 
19607  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19608  if( 0 == 0 )
19609  {
19610  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19611 
19612  if( strcmp( "FAIL", "79ee27adfa9698a97d217c5010ec807806feda37db811e398c3b82abf698aece08561fffc6c601d2691738e279eeb57e5804e1405a9913830e3ba0d7b979213ef40d733a19497d4bb1b8b2c609a8f904e29771fa230c39a48ebb8c3376f07c8013fff6e34f10fe53988a6ec87a9296c0a7cfba769adefe599ec6671012965973" ) == 0 )
19613  {
19614  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19615  }
19616  else
19617  {
19618  hexify( dst_str, output, pt_len );
19619 
19620  fct_chk( strcmp( (char *) dst_str, "79ee27adfa9698a97d217c5010ec807806feda37db811e398c3b82abf698aece08561fffc6c601d2691738e279eeb57e5804e1405a9913830e3ba0d7b979213ef40d733a19497d4bb1b8b2c609a8f904e29771fa230c39a48ebb8c3376f07c8013fff6e34f10fe53988a6ec87a9296c0a7cfba769adefe599ec6671012965973" ) == 0 );
19621  }
19622  }
19623  }
19624  FCT_TEST_END();
19625 
19626 
19627  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024120_2)
19628  {
19629  unsigned char key_str[128];
19630  unsigned char src_str[128];
19631  unsigned char dst_str[257];
19632  unsigned char iv_str[128];
19633  unsigned char add_str[128];
19634  unsigned char tag_str[128];
19635  unsigned char output[128];
19636  gcm_context ctx;
19637  unsigned int key_len;
19638  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
19639  int ret;
19640 
19641  memset(key_str, 0x00, 128);
19642  memset(src_str, 0x00, 128);
19643  memset(dst_str, 0x00, 257);
19644  memset(iv_str, 0x00, 128);
19645  memset(add_str, 0x00, 128);
19646  memset(tag_str, 0x00, 128);
19647  memset(output, 0x00, 128);
19648 
19649  key_len = unhexify( key_str, "5231ca6d772edd9ea2d251e22d7d455928c22474b4b44130dad57e6511fed6ee" );
19650  pt_len = unhexify( src_str, "2767c808410ee132291585ea74a48ad3102f883f07d060c91c5f10abd37fe0996d2210dc490260238ae15f5d74c7be2a1e15d80db09079c520047f88488a7802857a3fc3b81d85a96949997430a880177880a31d4d0c9c9045247804f057a4f2756d6e40375a4a3187c4376d6bf573ce334cda1ed88d8a50db499e7cdb89d8db" );
19651  iv_len = unhexify( iv_str, "048698a4a0feabc1f336112e2794795a" );
19652  add_len = unhexify( add_str, "3a81b6b0b722899ff931cb73c39222d555b83ae3f8880b982593cbc1ab8be90d1ee32fd7dfe697cf24c95b7309d82c3fed3aa6b3d5740cc86a28174ac8f17d860ebb251ac0d71751c2ff47b48bfb0b3beb4f51494464cda34feaecddb1dbbe5fa36c681ada0787d6ed728afc4008b95929a1905787917adc95f1034fedcd817a" );
19653  unhexify( tag_str, "ba61edeb7b8966188854fc7926aad2" );
19654 
19655  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19656  if( 0 == 0 )
19657  {
19658  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19659 
19660  if( strcmp( "FAIL", "FAIL" ) == 0 )
19661  {
19662  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19663  }
19664  else
19665  {
19666  hexify( dst_str, output, pt_len );
19667 
19668  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19669  }
19670  }
19671  }
19672  FCT_TEST_END();
19673 
19674 
19675  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024112_0)
19676  {
19677  unsigned char key_str[128];
19678  unsigned char src_str[128];
19679  unsigned char dst_str[257];
19680  unsigned char iv_str[128];
19681  unsigned char add_str[128];
19682  unsigned char tag_str[128];
19683  unsigned char output[128];
19684  gcm_context ctx;
19685  unsigned int key_len;
19686  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
19687  int ret;
19688 
19689  memset(key_str, 0x00, 128);
19690  memset(src_str, 0x00, 128);
19691  memset(dst_str, 0x00, 257);
19692  memset(iv_str, 0x00, 128);
19693  memset(add_str, 0x00, 128);
19694  memset(tag_str, 0x00, 128);
19695  memset(output, 0x00, 128);
19696 
19697  key_len = unhexify( key_str, "5a3f516a7898e04e5da4efd6c7c5989b77552d195464620c2b35b9a4fda29cce" );
19698  pt_len = unhexify( src_str, "5cc28b61ae97557774bdcd7ff653f4aa349df68d53c7e5a65263883ef1fe224ad40e86bffc2d38f28a2ed9ae1fc08563e2a1e46246106546eb8e6064c06baa0046fa137421734b7f0f94656a4f459d9d981717557d843700d116b6e5e2dd3af5f67c34edf31b40b71fd3c6f2475f9310feb70bcb973be52d41e86792c49d54c0" );
19699  iv_len = unhexify( iv_str, "9310af6974890c0a0364231f9cc8103d" );
19700  add_len = unhexify( add_str, "2103af8356bcb9dfc2a4f1d4ed09cbcd8e1990d23865605e19f87feb50bf8d10d0257740e5557a9297f0499c01e29a1a513ca18e6f43f7406c865cbe3951a7771128f3110c8da3bd696368901944549552842a1f6fd96cc681b45da098f3c1acb3d237d2363285f520d0b6714b698790b7660c52ac84a42c9721ac7e9d38a2ef" );
19701  unhexify( tag_str, "993fc8e7176557ee9eb8dd944691" );
19702 
19703  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19704  if( 0 == 0 )
19705  {
19706  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19707 
19708  if( strcmp( "FAIL", "FAIL" ) == 0 )
19709  {
19710  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19711  }
19712  else
19713  {
19714  hexify( dst_str, output, pt_len );
19715 
19716  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19717  }
19718  }
19719  }
19720  FCT_TEST_END();
19721 
19722 
19723  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024112_1)
19724  {
19725  unsigned char key_str[128];
19726  unsigned char src_str[128];
19727  unsigned char dst_str[257];
19728  unsigned char iv_str[128];
19729  unsigned char add_str[128];
19730  unsigned char tag_str[128];
19731  unsigned char output[128];
19732  gcm_context ctx;
19733  unsigned int key_len;
19734  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
19735  int ret;
19736 
19737  memset(key_str, 0x00, 128);
19738  memset(src_str, 0x00, 128);
19739  memset(dst_str, 0x00, 257);
19740  memset(iv_str, 0x00, 128);
19741  memset(add_str, 0x00, 128);
19742  memset(tag_str, 0x00, 128);
19743  memset(output, 0x00, 128);
19744 
19745  key_len = unhexify( key_str, "59c9258554363d8a885fc0f5d112fee08eadfc7ce52a0e7e73e3d0d41d9a0290" );
19746  pt_len = unhexify( src_str, "79c491411402ea7878e480519fd984dde44bce6459303bb76d4eaf97d4e345d1aafaa68ceb0590b41cfed0f411b675d9344c7e888cccfc9eb6fe6b229d198f94ba516ee850ee7f078a4f5f32a23f92f72264e3a76a31ebd042564315ac4f2ec0bb49ba6d08cfd2d3a6308688e39f28e3ecd669c588368cee8210edf5dbefb925" );
19747  iv_len = unhexify( iv_str, "77e51e89dc47bbcac79cca21e81a61de" );
19748  add_len = unhexify( add_str, "25a6f8800a9b914c0ebf9a45d72355c03ee72a138eb81b2980f332645ce1d7aa4659805821866aee2b276e2c032776b4eaf36f93b5f9a72b791be24e31eff105ca6d0700e3069ee327983dd7fe1c7465d6c6d77837aff69055149988e7199847fad98605c377d997dbd40f3e2ff1a4f978a493684e401249e69540fbde96323c" );
19749  unhexify( tag_str, "ee6d85d3f3703b45adb4f9b2f155" );
19750 
19751  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19752  if( 0 == 0 )
19753  {
19754  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19755 
19756  if( strcmp( "FAIL", "44ca68deed5478074adfddc97f06f44c08bf7bca4dee8707d621fc7396fe2efcdad0a167d1708a9ff59ce4cddb86920bf1dbdf41b2109a1815ffc4e596787319114cad8adab46cf7f080c9ef20bcf67a8441ba55eac449f979280319524c74cf247818a8c5478ea6f6770996026a43781285dd89c36212050afc88faa56135fb" ) == 0 )
19757  {
19758  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19759  }
19760  else
19761  {
19762  hexify( dst_str, output, pt_len );
19763 
19764  fct_chk( strcmp( (char *) dst_str, "44ca68deed5478074adfddc97f06f44c08bf7bca4dee8707d621fc7396fe2efcdad0a167d1708a9ff59ce4cddb86920bf1dbdf41b2109a1815ffc4e596787319114cad8adab46cf7f080c9ef20bcf67a8441ba55eac449f979280319524c74cf247818a8c5478ea6f6770996026a43781285dd89c36212050afc88faa56135fb" ) == 0 );
19765  }
19766  }
19767  }
19768  FCT_TEST_END();
19769 
19770 
19771  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024112_2)
19772  {
19773  unsigned char key_str[128];
19774  unsigned char src_str[128];
19775  unsigned char dst_str[257];
19776  unsigned char iv_str[128];
19777  unsigned char add_str[128];
19778  unsigned char tag_str[128];
19779  unsigned char output[128];
19780  gcm_context ctx;
19781  unsigned int key_len;
19782  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
19783  int ret;
19784 
19785  memset(key_str, 0x00, 128);
19786  memset(src_str, 0x00, 128);
19787  memset(dst_str, 0x00, 257);
19788  memset(iv_str, 0x00, 128);
19789  memset(add_str, 0x00, 128);
19790  memset(tag_str, 0x00, 128);
19791  memset(output, 0x00, 128);
19792 
19793  key_len = unhexify( key_str, "5e9eae594cb54c8089330e4404ff79abb1c0841b0be5347a14633ad1e1ff44fa" );
19794  pt_len = unhexify( src_str, "32abc1eb6077555a85a0a6fd1c78cccca6c8b375842e2eb8eee45ee6c38dc0837443d16c647252e8124639dd01c808ac5e857a25d927c2a75e2fa8955cad5beb5c206fc050cd933fc4621f5718936f01f39dd700ae1aee7537cc595df8789c5d1a6e1e87b1c7a60e3ce5d57c80dd65dee3801798e1481b1963bcc78cc69f8c50" );
19795  iv_len = unhexify( iv_str, "0917b486da754f48bb43ecc8766a7ce3" );
19796  add_len = unhexify( add_str, "2aa1ef2f91aeba5da10b48a882dbd4574df4e9157a18abf8cecd03e4176712ba171b6ecb0e745841ff84e35063e47b08101afc44cfd9cededb913a82f00b9d4bac922f23a22f200642270399896405d00fa5271718eefb4cd5fe7e5f32097766ebff36ff1898a1c8a1a01cc18e6121e470805c37ff298fc65ef2fb1b336d09fd" );
19797  unhexify( tag_str, "92282b022e393924ab9c65b258c2" );
19798 
19799  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19800  if( 0 == 0 )
19801  {
19802  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19803 
19804  if( strcmp( "FAIL", "FAIL" ) == 0 )
19805  {
19806  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19807  }
19808  else
19809  {
19810  hexify( dst_str, output, pt_len );
19811 
19812  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19813  }
19814  }
19815  }
19816  FCT_TEST_END();
19817 
19818 
19819  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024104_0)
19820  {
19821  unsigned char key_str[128];
19822  unsigned char src_str[128];
19823  unsigned char dst_str[257];
19824  unsigned char iv_str[128];
19825  unsigned char add_str[128];
19826  unsigned char tag_str[128];
19827  unsigned char output[128];
19828  gcm_context ctx;
19829  unsigned int key_len;
19830  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
19831  int ret;
19832 
19833  memset(key_str, 0x00, 128);
19834  memset(src_str, 0x00, 128);
19835  memset(dst_str, 0x00, 257);
19836  memset(iv_str, 0x00, 128);
19837  memset(add_str, 0x00, 128);
19838  memset(tag_str, 0x00, 128);
19839  memset(output, 0x00, 128);
19840 
19841  key_len = unhexify( key_str, "aaf03c3055a35362212b9b059931e7a24fc71e32bc9a533428c9dc31077f2ebc" );
19842  pt_len = unhexify( src_str, "c0e12cdd8233878505e025d52427536be7b6bf1887d2dd20eac7092db80b22417a3a4ca83cdf5bc5e36161be1ff9b73f7ceb297c6d07c9cb2a75035a5dc079e48283daea60596f4b356ca28c243e628cbe459f069709fe193394c9b1a31d8ccc5a3a4eba30056c415e68571a2c34bb5c32efff12e9aa483c4a68be5e76aba4cd" );
19843  iv_len = unhexify( iv_str, "7dfccd077b29e6ed5720244bb76bde9f" );
19844  add_len = unhexify( add_str, "21edd1c6056f51fd5f314e5c26728182edcd9df92877f30498949098dcde8089eed84e76d774ef8874d77125669a302d268b99dcd66b349d0271dde6f8cc94dc4f2df3787887b1173cad94d067e346846befb108005387102854d9387d2c0fbc9636cdf73a10d145f4b612c201b46e1ff4465f6a7654ce3da5792daf9a27fb35" );
19845  unhexify( tag_str, "6154c6799ad7cdc2d89801943a" );
19846 
19847  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19848  if( 0 == 0 )
19849  {
19850  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19851 
19852  if( strcmp( "FAIL", "FAIL" ) == 0 )
19853  {
19854  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19855  }
19856  else
19857  {
19858  hexify( dst_str, output, pt_len );
19859 
19860  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19861  }
19862  }
19863  }
19864  FCT_TEST_END();
19865 
19866 
19867  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024104_1)
19868  {
19869  unsigned char key_str[128];
19870  unsigned char src_str[128];
19871  unsigned char dst_str[257];
19872  unsigned char iv_str[128];
19873  unsigned char add_str[128];
19874  unsigned char tag_str[128];
19875  unsigned char output[128];
19876  gcm_context ctx;
19877  unsigned int key_len;
19878  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
19879  int ret;
19880 
19881  memset(key_str, 0x00, 128);
19882  memset(src_str, 0x00, 128);
19883  memset(dst_str, 0x00, 257);
19884  memset(iv_str, 0x00, 128);
19885  memset(add_str, 0x00, 128);
19886  memset(tag_str, 0x00, 128);
19887  memset(output, 0x00, 128);
19888 
19889  key_len = unhexify( key_str, "60c775971a9eac7950ed2bdd85bd60fe948ba04c419f6743fb67f37557e46c6e" );
19890  pt_len = unhexify( src_str, "8abb2e66a4d08074916056bb8e925551372f737f0e1b597c5d08ee102989743a273b29d7281013f8b3aee2934399cb427370d70370ee86eb41584b653660c633506a53cae747826bb7d93909f069d5aacf058b7f2bbdc58ea08653db857bda83a979fc22a4f126dfef7aac45177f4cdb802fab0c812fb35d12a8176ec21336d7" );
19891  iv_len = unhexify( iv_str, "9b92ad7079b0de09c94091386577338b" );
19892  add_len = unhexify( add_str, "1f6a84b0df75bd99a2a64849e9686957c6a60932ebe898d033128be9b757e9890225925d856bfdc33ff514c63145f357730bb0435c65342bc5e025267b410af6fd388a5eca01b7efc87fd3b1b791df791bd47dfab736350d7b7f368b4100e04c939d5af957bab95ed502dac904e969876674602a0f0790da2d7351b686e46590" );
19893  unhexify( tag_str, "1d6cd4ab3914e109f22668867f" );
19894 
19895  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19896  if( 0 == 0 )
19897  {
19898  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19899 
19900  if( strcmp( "FAIL", "FAIL" ) == 0 )
19901  {
19902  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19903  }
19904  else
19905  {
19906  hexify( dst_str, output, pt_len );
19907 
19908  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
19909  }
19910  }
19911  }
19912  FCT_TEST_END();
19913 
19914 
19915  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024104_2)
19916  {
19917  unsigned char key_str[128];
19918  unsigned char src_str[128];
19919  unsigned char dst_str[257];
19920  unsigned char iv_str[128];
19921  unsigned char add_str[128];
19922  unsigned char tag_str[128];
19923  unsigned char output[128];
19924  gcm_context ctx;
19925  unsigned int key_len;
19926  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
19927  int ret;
19928 
19929  memset(key_str, 0x00, 128);
19930  memset(src_str, 0x00, 128);
19931  memset(dst_str, 0x00, 257);
19932  memset(iv_str, 0x00, 128);
19933  memset(add_str, 0x00, 128);
19934  memset(tag_str, 0x00, 128);
19935  memset(output, 0x00, 128);
19936 
19937  key_len = unhexify( key_str, "3b426e449337a14bc0663246ab61b671b523c9a3130c21ed59c93fa6a5aa5ae3" );
19938  pt_len = unhexify( src_str, "291bd5a00d71eb7d547b7c94e7030ba4a947418eaeb378a3bacd304b08c6f92f6958eaba968ac6aa23e0512a2a8ad7c1ca2f8fcf623bfc1281f5b7b598c08d2aebcd447668b23238c5e338b4c2ac7f8fd381714c596ea3e0c17aca4317a08563e58f0f52a8af08e078dc242ae54ee0fe3869f8c9687b004a4ded0aa27d8f4c5d" );
19939  iv_len = unhexify( iv_str, "e6efc96acd105fe4a48d1ac931eea096" );
19940  add_len = unhexify( add_str, "0902cf7a0685444126369712ac47962bc2f7a3a5837f1b6190d9ab1adb4cd35e7f0892eee628b8e07fcf2b598cebe1ec07d8c4823172ae66a135bb51cc71590707b691a66b56af1ffe38772911d11685da355728eaddd83752d21c119d7b59f4c17c2403629fa55cd70cd331aed7b0de673c85f25c2e9e0267f53f0b7480c8ca" );
19941  unhexify( tag_str, "ca4bfeedcd19d301d3f08cb729" );
19942 
19943  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19944  if( 0 == 0 )
19945  {
19946  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19947 
19948  if( strcmp( "FAIL", "bcef3f2fd101b828d36cb38530cf9a0a7a285ac1c55ee1069cc78466327e85887534c98a8891d579effd832c0f7d6e7e822fb1eea85a39317a547591def4aeed6660872859fc9d1df9725d3c40e9ccaa900e0f1426a55d20ac4f2e8e07bd3bbc687f8e059ab93e7604c97e75ac94be1c8c24f4c4da0080a4d77953fb090cbb62" ) == 0 )
19949  {
19950  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19951  }
19952  else
19953  {
19954  hexify( dst_str, output, pt_len );
19955 
19956  fct_chk( strcmp( (char *) dst_str, "bcef3f2fd101b828d36cb38530cf9a0a7a285ac1c55ee1069cc78466327e85887534c98a8891d579effd832c0f7d6e7e822fb1eea85a39317a547591def4aeed6660872859fc9d1df9725d3c40e9ccaa900e0f1426a55d20ac4f2e8e07bd3bbc687f8e059ab93e7604c97e75ac94be1c8c24f4c4da0080a4d77953fb090cbb62" ) == 0 );
19957  }
19958  }
19959  }
19960  FCT_TEST_END();
19961 
19962 
19963  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102496_0)
19964  {
19965  unsigned char key_str[128];
19966  unsigned char src_str[128];
19967  unsigned char dst_str[257];
19968  unsigned char iv_str[128];
19969  unsigned char add_str[128];
19970  unsigned char tag_str[128];
19971  unsigned char output[128];
19972  gcm_context ctx;
19973  unsigned int key_len;
19974  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
19975  int ret;
19976 
19977  memset(key_str, 0x00, 128);
19978  memset(src_str, 0x00, 128);
19979  memset(dst_str, 0x00, 257);
19980  memset(iv_str, 0x00, 128);
19981  memset(add_str, 0x00, 128);
19982  memset(tag_str, 0x00, 128);
19983  memset(output, 0x00, 128);
19984 
19985  key_len = unhexify( key_str, "ceaf204ff504ea8e7fade1a2097f2b527a44766860447322fa5ad346cd810217" );
19986  pt_len = unhexify( src_str, "1c8e4cf6018211518494d46c2e0607fa42e236abc28d58f8175c530f84b1f030572f5f6a74cb5517e1fb999a637d352afcbeadea9121e695675859b66b499a3a351ecba5226e58ebbb59fe12e359e4c89cd51c8703d4643c49921ae495801c73627df404b91e828e1d0e03ae09a39defb5aa5f2c8106953772ba0713d3261329" );
19987  iv_len = unhexify( iv_str, "cfdb8183251f4b61c64e73243594fdc6" );
19988  add_len = unhexify( add_str, "a60f3969fd1b14793dd1425aa0b1f742a4861e0b50eaffd1525cd209ba6d1252176763bb5bee59aaa55f92341cdc0705899aba44cf0ec05cbf80274ebef65cd9507fd4224b25cac19610968d6a37e2daf9ddf046ef158ef512401f8fd0e4f95662eebdee09dd4a7894cc8c409be086d41280bd78d6bc04c35a4e8cd3a2e83be3" );
19989  unhexify( tag_str, "9e45029f4f13a4767ee05cec" );
19990 
19991  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
19992  if( 0 == 0 )
19993  {
19994  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
19995 
19996  if( strcmp( "FAIL", "5cdc66b587ed5eebb04f42b83a6ab7017093514881c598cce332d74fa3fab927493ac15bff26835296e080b5b45ef907c0529fc2f4ed2fc09db179ef598e5d193ea60c301d3f8d823404814e3e74de0e1d2417c963e9246c353201c7a42659d447376e7d05c579dd4c3ae51c2436407b8eff16ec31f592f04b8013efcfd0f367" ) == 0 )
19997  {
19998  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
19999  }
20000  else
20001  {
20002  hexify( dst_str, output, pt_len );
20003 
20004  fct_chk( strcmp( (char *) dst_str, "5cdc66b587ed5eebb04f42b83a6ab7017093514881c598cce332d74fa3fab927493ac15bff26835296e080b5b45ef907c0529fc2f4ed2fc09db179ef598e5d193ea60c301d3f8d823404814e3e74de0e1d2417c963e9246c353201c7a42659d447376e7d05c579dd4c3ae51c2436407b8eff16ec31f592f04b8013efcfd0f367" ) == 0 );
20005  }
20006  }
20007  }
20008  FCT_TEST_END();
20009 
20010 
20011  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102496_1)
20012  {
20013  unsigned char key_str[128];
20014  unsigned char src_str[128];
20015  unsigned char dst_str[257];
20016  unsigned char iv_str[128];
20017  unsigned char add_str[128];
20018  unsigned char tag_str[128];
20019  unsigned char output[128];
20020  gcm_context ctx;
20021  unsigned int key_len;
20022  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
20023  int ret;
20024 
20025  memset(key_str, 0x00, 128);
20026  memset(src_str, 0x00, 128);
20027  memset(dst_str, 0x00, 257);
20028  memset(iv_str, 0x00, 128);
20029  memset(add_str, 0x00, 128);
20030  memset(tag_str, 0x00, 128);
20031  memset(output, 0x00, 128);
20032 
20033  key_len = unhexify( key_str, "15652abe38cd09777bba21d0db04637f5737d3cb3922181b9f2d07bfdafd327a" );
20034  pt_len = unhexify( src_str, "1d6c153dec3b4738a09c9fbdfe31a093eb7ea79b8fa49f83e5e1f46893590f074fb171fb66e30ef887767014e3a10a3aa05da2bd50dd7b7936e1d7f6f31af9030e31e76bdf147f4396464db0f6a72511c4885c6c2305d339906e3c761a3249d7ebea3bf463e8b79c3706e684575550e964b8047979f7aed6ea05056c4b5840b1" );
20035  iv_len = unhexify( iv_str, "3a5e0d223ae981efb405566264e3e776" );
20036  add_len = unhexify( add_str, "cd755437cb61b539908e0cfaaa36c0123f8f17d1e6539783cb61d4b56cac3bc1e971c1ea558b12669b025cb6b9ad55991c6e2f8ee8b0b7901790193e226a0fbbfff7ff0bee6a554660b9f32e061b6c04bf048484ff9ebd492f7e50e744edd72d02c8fd32f87f9421bf18a5a20ebb4d9dbe39a13c34b7296232470e8be587ba09" );
20037  unhexify( tag_str, "01a573d8e99c884563310954" );
20038 
20039  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20040  if( 0 == 0 )
20041  {
20042  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20043 
20044  if( strcmp( "FAIL", "162430c23f7adcf98575a2d9249b4b5cec42efae33776360ebfa6a19c8eee4bd6b07cbd274deadc3292b7cdbb7803e99d9f67ccc5077f3ad5808f339a05b3213dbfd11377673d4f9b486a67a72a9ac8ea9ba699861dce0de7e2fd83d3ba2a2ec7fabf18b95a2bbe2184ff7bddd63111b560b3afe7f2c76807614ba36c1b011fb" ) == 0 )
20045  {
20046  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20047  }
20048  else
20049  {
20050  hexify( dst_str, output, pt_len );
20051 
20052  fct_chk( strcmp( (char *) dst_str, "162430c23f7adcf98575a2d9249b4b5cec42efae33776360ebfa6a19c8eee4bd6b07cbd274deadc3292b7cdbb7803e99d9f67ccc5077f3ad5808f339a05b3213dbfd11377673d4f9b486a67a72a9ac8ea9ba699861dce0de7e2fd83d3ba2a2ec7fabf18b95a2bbe2184ff7bddd63111b560b3afe7f2c76807614ba36c1b011fb" ) == 0 );
20053  }
20054  }
20055  }
20056  FCT_TEST_END();
20057 
20058 
20059  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102496_2)
20060  {
20061  unsigned char key_str[128];
20062  unsigned char src_str[128];
20063  unsigned char dst_str[257];
20064  unsigned char iv_str[128];
20065  unsigned char add_str[128];
20066  unsigned char tag_str[128];
20067  unsigned char output[128];
20068  gcm_context ctx;
20069  unsigned int key_len;
20070  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
20071  int ret;
20072 
20073  memset(key_str, 0x00, 128);
20074  memset(src_str, 0x00, 128);
20075  memset(dst_str, 0x00, 257);
20076  memset(iv_str, 0x00, 128);
20077  memset(add_str, 0x00, 128);
20078  memset(tag_str, 0x00, 128);
20079  memset(output, 0x00, 128);
20080 
20081  key_len = unhexify( key_str, "a43f6d07042a15cd49f6f52a2a3a67c6c2ff420d95bb94b9fe03b287c3abcaf8" );
20082  pt_len = unhexify( src_str, "b67e58c8b608724fd20aa097ee483bc4c804490cc79de635170944af75c87ae0ad8261365c1dc80d852553bcba18da9fbc3fbe61d27550a03003ef0c60202054626655509a9e1ab54677e537a4e761df011d6c6dd041c795446b384161ae9eab441afd24d19b58eb4fe5116cd7b11b751ebbd0a2adba7afc380d9d775177099a" );
20083  iv_len = unhexify( iv_str, "3b6fad21f0034bba8b1f7a344edf7a3c" );
20084  add_len = unhexify( add_str, "2e01c0523c8293fc51388281dccdb8d0a2d215d729289deb327b8142d716c2bb849e9476545b82f3882ba7961b70c5da2a925ba18b6b121e9215d52ac479c9129c9cd28f81584ff84509d5f9dcb7eaae66911b303cc388efa5020ac26a9cd9ea953f61992a306eb4b35bcd8447eea63cef37bb0c95c1e37811115cf26c53e8c5" );
20085  unhexify( tag_str, "43470bc3d7c573cb3a5230f5" );
20086 
20087  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20088  if( 0 == 0 )
20089  {
20090  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20091 
20092  if( strcmp( "FAIL", "e1720d451fa7ab9db4988567187244b15b6fe795dd4fef579fb72e41b21aaa436d2e5d8735a4abd232a3fb9188c75c247f6034cdebb07fd7f260f8e54efefa4f2981cafa510dd5c482a27753a7c015b3cae1c18c7c99a6d6daa4781b80f18bbe6620bfc1518a32531017a1a52aadb96a7794887c11ad6bdd68187ba14f72a4b5" ) == 0 )
20093  {
20094  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20095  }
20096  else
20097  {
20098  hexify( dst_str, output, pt_len );
20099 
20100  fct_chk( strcmp( (char *) dst_str, "e1720d451fa7ab9db4988567187244b15b6fe795dd4fef579fb72e41b21aaa436d2e5d8735a4abd232a3fb9188c75c247f6034cdebb07fd7f260f8e54efefa4f2981cafa510dd5c482a27753a7c015b3cae1c18c7c99a6d6daa4781b80f18bbe6620bfc1518a32531017a1a52aadb96a7794887c11ad6bdd68187ba14f72a4b5" ) == 0 );
20101  }
20102  }
20103  }
20104  FCT_TEST_END();
20105 
20106 
20107  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102464_0)
20108  {
20109  unsigned char key_str[128];
20110  unsigned char src_str[128];
20111  unsigned char dst_str[257];
20112  unsigned char iv_str[128];
20113  unsigned char add_str[128];
20114  unsigned char tag_str[128];
20115  unsigned char output[128];
20116  gcm_context ctx;
20117  unsigned int key_len;
20118  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
20119  int ret;
20120 
20121  memset(key_str, 0x00, 128);
20122  memset(src_str, 0x00, 128);
20123  memset(dst_str, 0x00, 257);
20124  memset(iv_str, 0x00, 128);
20125  memset(add_str, 0x00, 128);
20126  memset(tag_str, 0x00, 128);
20127  memset(output, 0x00, 128);
20128 
20129  key_len = unhexify( key_str, "1f0f0191e18db07c0501dbab4ed952c5603a4cd249d2d8d17e62e10b96ae713f" );
20130  pt_len = unhexify( src_str, "aad40e7866c26e486b6f6e8eb14a130d5f88891bf0d09aa8fe32f447ab8dea7bee5d3eda4499c0103a010483f2b64fdf1155499d31decf528c77dd7627884f9995c213cf7402143dbb7561d69c86886734260ac94ffac7eb33598d25714228ef43f744ec1af2a87e789f1e5d6fff0fbd5082dcc49328f194e8f8a14a5bfc962d" );
20131  iv_len = unhexify( iv_str, "ab8be16b4db809c81be4684b726c05ab" );
20132  add_len = unhexify( add_str, "a5a6e828352a44bd438ad58de80011be0408d410f6e762e3145f8b264a70c593476b41bb87875746c97de7d5fab120bd2f716b37c343608ee48d197a46c7546fafcdbe3e7688b7e9d2f5b6319c91d3881d804546b5f3dbe480996968dd046f406c11f0dc671be0421cbc8b4ea6811dd504281518bb96148dddf9f0dc4e2e2436" );
20133  unhexify( tag_str, "d8bd7d8773893519" );
20134 
20135  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20136  if( 0 == 0 )
20137  {
20138  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20139 
20140  if( strcmp( "FAIL", "FAIL" ) == 0 )
20141  {
20142  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20143  }
20144  else
20145  {
20146  hexify( dst_str, output, pt_len );
20147 
20148  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20149  }
20150  }
20151  }
20152  FCT_TEST_END();
20153 
20154 
20155  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102464_1)
20156  {
20157  unsigned char key_str[128];
20158  unsigned char src_str[128];
20159  unsigned char dst_str[257];
20160  unsigned char iv_str[128];
20161  unsigned char add_str[128];
20162  unsigned char tag_str[128];
20163  unsigned char output[128];
20164  gcm_context ctx;
20165  unsigned int key_len;
20166  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
20167  int ret;
20168 
20169  memset(key_str, 0x00, 128);
20170  memset(src_str, 0x00, 128);
20171  memset(dst_str, 0x00, 257);
20172  memset(iv_str, 0x00, 128);
20173  memset(add_str, 0x00, 128);
20174  memset(tag_str, 0x00, 128);
20175  memset(output, 0x00, 128);
20176 
20177  key_len = unhexify( key_str, "a6cf7d83137f57f2310ee6bf31e8883952bb07ccdc12f516233ed533ea967e5d" );
20178  pt_len = unhexify( src_str, "83ab20698fd7573fd121976a72b45a7f03aad84702fc8ac73d6926eabd8a546895aeffe4ba81d117507e2cd37d58eeff71cc3afa8a4449be85f228ea52f6dc6395bb43c1c9f795343720841682d9b2f00602eafa4d4cbe297bfc62467e526b9d823cc8eeecd9e5f8dbc2f65610663c6f37b3d896651b254bd60215629ade3b2a" );
20179  iv_len = unhexify( iv_str, "f17e37e73a28c682366bfe619cc673bb" );
20180  add_len = unhexify( add_str, "0f4dd201b18e20230b6233e0d7add6f96537dd4e82d3d0704c047fab41af5faf6bd52bd14fa9a072f81d92a2ce04352f0b66f088c67102d2d127a9850b09ff6087f194a6e8ccaba24091feb303eebb65f1203b2d22af44e7be4de71f03e6f6cbadf28e15af58f58eb62e5bddfae06df773cc3f0942520de20078dda752e3270f" );
20181  unhexify( tag_str, "74110471ccd75912" );
20182 
20183  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20184  if( 0 == 0 )
20185  {
20186  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20187 
20188  if( strcmp( "FAIL", "FAIL" ) == 0 )
20189  {
20190  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20191  }
20192  else
20193  {
20194  hexify( dst_str, output, pt_len );
20195 
20196  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20197  }
20198  }
20199  }
20200  FCT_TEST_END();
20201 
20202 
20203  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102464_2)
20204  {
20205  unsigned char key_str[128];
20206  unsigned char src_str[128];
20207  unsigned char dst_str[257];
20208  unsigned char iv_str[128];
20209  unsigned char add_str[128];
20210  unsigned char tag_str[128];
20211  unsigned char output[128];
20212  gcm_context ctx;
20213  unsigned int key_len;
20214  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
20215  int ret;
20216 
20217  memset(key_str, 0x00, 128);
20218  memset(src_str, 0x00, 128);
20219  memset(dst_str, 0x00, 257);
20220  memset(iv_str, 0x00, 128);
20221  memset(add_str, 0x00, 128);
20222  memset(tag_str, 0x00, 128);
20223  memset(output, 0x00, 128);
20224 
20225  key_len = unhexify( key_str, "b0c85ac6b3887639838ddca94c5c69f38115aa00122322c8114642d12ea1b8fe" );
20226  pt_len = unhexify( src_str, "0210fce418e7e2199cb8f899c81b9be74a630d00269755f882fc4db27632e99685cc12c426a7503473646df1288d0ede28408be9add5713628700f8e2b2e27d7522520ed00ac47239084651eb99e7d03e1520aae137b768f3144232c16b72158fd5da4a26a2525b9b27791bf06d1eb2e671c54daf64fddc1420bc2a30a324ba5" );
20227  iv_len = unhexify( iv_str, "14f68e533ecf02bceb9a504d452e78c7" );
20228  add_len = unhexify( add_str, "796a46236fd0ff6572b1d6257c874038f870aa71cbb06b39046d0fb6489d6ae8622b5154292ae5c4e1d5ff706daedb2e812533ae3a635d339a7fbe53780e3e8204924a5deb4b6856618f4c7465d125a3edffe1ab8f88b31d49537791c0f3171f08dbb5ed1d9ed863dafbae4ecb46824a4922862fe0954ee2caa09ab0e77ed8fc" );
20229  unhexify( tag_str, "6fb0b5c83b5212bf" );
20230 
20231  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20232  if( 0 == 0 )
20233  {
20234  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20235 
20236  if( strcmp( "FAIL", "5e6c362f7587936bcb306673713a6f1fb080783a20e9bbb906456973e529cfa0298206184509c30e1d3793eaaa5d564edd4488f04311821eb652e0a1f4adaf6971505ca014788c8ce085ceb3523d70284ed2bb0aebeba7af83d484df69c87f55a93b3d87baa43bd301c4e55eb8c45dcf3e4612535ea1bd5fdb4c3b9056d0cae9" ) == 0 )
20237  {
20238  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20239  }
20240  else
20241  {
20242  hexify( dst_str, output, pt_len );
20243 
20244  fct_chk( strcmp( (char *) dst_str, "5e6c362f7587936bcb306673713a6f1fb080783a20e9bbb906456973e529cfa0298206184509c30e1d3793eaaa5d564edd4488f04311821eb652e0a1f4adaf6971505ca014788c8ce085ceb3523d70284ed2bb0aebeba7af83d484df69c87f55a93b3d87baa43bd301c4e55eb8c45dcf3e4612535ea1bd5fdb4c3b9056d0cae9" ) == 0 );
20245  }
20246  }
20247  }
20248  FCT_TEST_END();
20249 
20250 
20251  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102432_0)
20252  {
20253  unsigned char key_str[128];
20254  unsigned char src_str[128];
20255  unsigned char dst_str[257];
20256  unsigned char iv_str[128];
20257  unsigned char add_str[128];
20258  unsigned char tag_str[128];
20259  unsigned char output[128];
20260  gcm_context ctx;
20261  unsigned int key_len;
20262  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
20263  int ret;
20264 
20265  memset(key_str, 0x00, 128);
20266  memset(src_str, 0x00, 128);
20267  memset(dst_str, 0x00, 257);
20268  memset(iv_str, 0x00, 128);
20269  memset(add_str, 0x00, 128);
20270  memset(tag_str, 0x00, 128);
20271  memset(output, 0x00, 128);
20272 
20273  key_len = unhexify( key_str, "e61b1a6b40e2ab1245ff65dcfb9948318ac4fe55e9ed600cec301dae32ae0e93" );
20274  pt_len = unhexify( src_str, "8d67fa9fcf078e421cb63abeb25dba739ab0e09a091dd06b0c616e1e888f350edb2d73a42f57f115266ea20c7f8fc143ac746649612df06a5e29b4a15934dc049be1ab49d018ab86c4f37d8c3d9c714f038029e74d8ee3dbe61d81adc63712ea413b37f7604da12107aa1695d9b0981e5a92cdfaa5fbda0e31b22c6fd6f3b499" );
20275  iv_len = unhexify( iv_str, "c356244b3034d288e4d4fe901b8e27c1" );
20276  add_len = unhexify( add_str, "bdcfeb09d5b97bab05a7acd9849e7de2c5beb7a4dc573c7e1c1d0c0409245a6584023114fdcc6413c800ca16847bde750b27c4d590248e2ce457c19b0f614f6aff4d78d4a19b3251531e5e852fbb05d09412cc1ff8988d1955ca6f5fe2d820f20a7642e3ae69e8122b06ba0918e806400b9b615e1abe6fdd4f56a7d02d649083" );
20277  unhexify( tag_str, "86acc02f" );
20278 
20279  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20280  if( 0 == 0 )
20281  {
20282  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20283 
20284  if( strcmp( "FAIL", "7c73182eca97d9617abb478a6ce62e3491a7e9951981c89c3071b161a4c80440614c3f24d0155073e28dcccee96bc8303dab4901ef77318df522d16d9da47770ef022395d6104cd623d93d67090a27507fc8ca04157e7939e639c62cd0e7d8a472314833c0eaa9ba2fd54a25b02854e3bff25cccd638885c082374ae520ed392" ) == 0 )
20285  {
20286  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20287  }
20288  else
20289  {
20290  hexify( dst_str, output, pt_len );
20291 
20292  fct_chk( strcmp( (char *) dst_str, "7c73182eca97d9617abb478a6ce62e3491a7e9951981c89c3071b161a4c80440614c3f24d0155073e28dcccee96bc8303dab4901ef77318df522d16d9da47770ef022395d6104cd623d93d67090a27507fc8ca04157e7939e639c62cd0e7d8a472314833c0eaa9ba2fd54a25b02854e3bff25cccd638885c082374ae520ed392" ) == 0 );
20293  }
20294  }
20295  }
20296  FCT_TEST_END();
20297 
20298 
20299  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102432_1)
20300  {
20301  unsigned char key_str[128];
20302  unsigned char src_str[128];
20303  unsigned char dst_str[257];
20304  unsigned char iv_str[128];
20305  unsigned char add_str[128];
20306  unsigned char tag_str[128];
20307  unsigned char output[128];
20308  gcm_context ctx;
20309  unsigned int key_len;
20310  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
20311  int ret;
20312 
20313  memset(key_str, 0x00, 128);
20314  memset(src_str, 0x00, 128);
20315  memset(dst_str, 0x00, 257);
20316  memset(iv_str, 0x00, 128);
20317  memset(add_str, 0x00, 128);
20318  memset(tag_str, 0x00, 128);
20319  memset(output, 0x00, 128);
20320 
20321  key_len = unhexify( key_str, "4f5a02e9843d28c8c226ed70d44b8fced8fb757ab6ece4d4f06e3c3cec79e44f" );
20322  pt_len = unhexify( src_str, "3ec13950d329f24074714c583bdc35686b811f775b76b0a8fcfa66fc56426c9d022f8ab0af38f8d2f71a068548330cdbe891670181ed7491bf40c739ef4dd93689fd35929b225089d2b151f83d9b3cd767300611144586767354c0491112c205409f3168092d27f9b9f433afb79820a2811984d48e70c1fb2a13bbb3ddbc53fb" );
20323  iv_len = unhexify( iv_str, "099e5d9aae89fb6391a18adf844a758e" );
20324  add_len = unhexify( add_str, "ad93e8662c3196e48cfdb5aa3bc923cd204151aa980cbec78f0d592b701f779c1c49f9e8686d7e2385a4146b21a643a59c18c8b82214f42560bcd686fad7c7c8e8c1944ce6b20ec9537dd14b6cf2592740ca112f4cd582250d69f240d3e957040e1f7e19c60b3c8f2bd00cb666604c38946eb9b2f17336d281b4794f71e538a2" );
20325  unhexify( tag_str, "30298885" );
20326 
20327  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20328  if( 0 == 0 )
20329  {
20330  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20331 
20332  if( strcmp( "FAIL", "FAIL" ) == 0 )
20333  {
20334  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20335  }
20336  else
20337  {
20338  hexify( dst_str, output, pt_len );
20339 
20340  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20341  }
20342  }
20343  }
20344  FCT_TEST_END();
20345 
20346 
20347  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102432_2)
20348  {
20349  unsigned char key_str[128];
20350  unsigned char src_str[128];
20351  unsigned char dst_str[257];
20352  unsigned char iv_str[128];
20353  unsigned char add_str[128];
20354  unsigned char tag_str[128];
20355  unsigned char output[128];
20356  gcm_context ctx;
20357  unsigned int key_len;
20358  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
20359  int ret;
20360 
20361  memset(key_str, 0x00, 128);
20362  memset(src_str, 0x00, 128);
20363  memset(dst_str, 0x00, 257);
20364  memset(iv_str, 0x00, 128);
20365  memset(add_str, 0x00, 128);
20366  memset(tag_str, 0x00, 128);
20367  memset(output, 0x00, 128);
20368 
20369  key_len = unhexify( key_str, "1cdb218e0bd0e02156e5b48182990f778889793ef6018a8928e61164ac047c8e" );
20370  pt_len = unhexify( src_str, "4d039618a0eb640329f90fe97de18bc928fc3fc7a0db42c97774bec2e882e872fc1097c8319f7837a16516bf387b1bae321c565e8fc1cb8480f051158e4685f0adba310d2c6253bc1300403cbd3f7ddcb2796a69f8bf9e73d47aada9a02673c1a3d5ecdac838abf22b385906236529a1b7dd5b8af2611a04cf4f83b15ba41cfc" );
20371  iv_len = unhexify( iv_str, "d2ffbb176f86bee958e08e5c7c6357c7" );
20372  add_len = unhexify( add_str, "bc580c4223f34e4f867d97febf9b03629d1c00c73df94436852cafd1408c945c5474c554cb0faf2bae35d3160c823d339a64ebd607cf765fa91f416fc6db042bc2bd7445c129b4a0e04b6f92a7b7b669eb70be9f9b2569e774db7cb7ae83943e3a12d29221356e08e5bf1b09e65f193d00d9fe89f82b84b3b8b062e649163dc8" );
20373  unhexify( tag_str, "1997daa9" );
20374 
20375  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20376  if( 0 == 0 )
20377  {
20378  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20379 
20380  if( strcmp( "FAIL", "FAIL" ) == 0 )
20381  {
20382  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20383  }
20384  else
20385  {
20386  hexify( dst_str, output, pt_len );
20387 
20388  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20389  }
20390  }
20391  }
20392  FCT_TEST_END();
20393 
20394 
20395  FCT_TEST_BGN(gcm_nist_validation_aes_25612800128_0)
20396  {
20397  unsigned char key_str[128];
20398  unsigned char src_str[128];
20399  unsigned char dst_str[257];
20400  unsigned char iv_str[128];
20401  unsigned char add_str[128];
20402  unsigned char tag_str[128];
20403  unsigned char output[128];
20404  gcm_context ctx;
20405  unsigned int key_len;
20406  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
20407  int ret;
20408 
20409  memset(key_str, 0x00, 128);
20410  memset(src_str, 0x00, 128);
20411  memset(dst_str, 0x00, 257);
20412  memset(iv_str, 0x00, 128);
20413  memset(add_str, 0x00, 128);
20414  memset(tag_str, 0x00, 128);
20415  memset(output, 0x00, 128);
20416 
20417  key_len = unhexify( key_str, "dc1a145c18bdbca760f35eea0d4a5992de04a0615964ec8b419c8288ab1470f0" );
20418  pt_len = unhexify( src_str, "" );
20419  iv_len = unhexify( iv_str, "7f8368254955e1b6d55b5c64458f3e66" );
20420  add_len = unhexify( add_str, "" );
20421  unhexify( tag_str, "8ddaa2c3ed09d53731834fa932d9d3af" );
20422 
20423  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20424  if( 0 == 0 )
20425  {
20426  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20427 
20428  if( strcmp( "FAIL", "FAIL" ) == 0 )
20429  {
20430  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20431  }
20432  else
20433  {
20434  hexify( dst_str, output, pt_len );
20435 
20436  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20437  }
20438  }
20439  }
20440  FCT_TEST_END();
20441 
20442 
20443  FCT_TEST_BGN(gcm_nist_validation_aes_25612800128_1)
20444  {
20445  unsigned char key_str[128];
20446  unsigned char src_str[128];
20447  unsigned char dst_str[257];
20448  unsigned char iv_str[128];
20449  unsigned char add_str[128];
20450  unsigned char tag_str[128];
20451  unsigned char output[128];
20452  gcm_context ctx;
20453  unsigned int key_len;
20454  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
20455  int ret;
20456 
20457  memset(key_str, 0x00, 128);
20458  memset(src_str, 0x00, 128);
20459  memset(dst_str, 0x00, 257);
20460  memset(iv_str, 0x00, 128);
20461  memset(add_str, 0x00, 128);
20462  memset(tag_str, 0x00, 128);
20463  memset(output, 0x00, 128);
20464 
20465  key_len = unhexify( key_str, "7b4766d3a6615ee58b390daa228ae7a541c46ce80a1efe227cc43cb777df3232" );
20466  pt_len = unhexify( src_str, "" );
20467  iv_len = unhexify( iv_str, "274367f31ec16601fe87a8e35b7a22dd" );
20468  add_len = unhexify( add_str, "" );
20469  unhexify( tag_str, "5f3a757b596e06e9b246ed9bac9397f9" );
20470 
20471  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20472  if( 0 == 0 )
20473  {
20474  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20475 
20476  if( strcmp( "FAIL", "FAIL" ) == 0 )
20477  {
20478  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20479  }
20480  else
20481  {
20482  hexify( dst_str, output, pt_len );
20483 
20484  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20485  }
20486  }
20487  }
20488  FCT_TEST_END();
20489 
20490 
20491  FCT_TEST_BGN(gcm_nist_validation_aes_25612800128_2)
20492  {
20493  unsigned char key_str[128];
20494  unsigned char src_str[128];
20495  unsigned char dst_str[257];
20496  unsigned char iv_str[128];
20497  unsigned char add_str[128];
20498  unsigned char tag_str[128];
20499  unsigned char output[128];
20500  gcm_context ctx;
20501  unsigned int key_len;
20502  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
20503  int ret;
20504 
20505  memset(key_str, 0x00, 128);
20506  memset(src_str, 0x00, 128);
20507  memset(dst_str, 0x00, 257);
20508  memset(iv_str, 0x00, 128);
20509  memset(add_str, 0x00, 128);
20510  memset(tag_str, 0x00, 128);
20511  memset(output, 0x00, 128);
20512 
20513  key_len = unhexify( key_str, "d19b04055bf6e7ff82e89daef66c9d8319ab25f9197e559444c5729b92c4f338" );
20514  pt_len = unhexify( src_str, "" );
20515  iv_len = unhexify( iv_str, "796efaff4f172bef78453d36a237cd36" );
20516  add_len = unhexify( add_str, "" );
20517  unhexify( tag_str, "3b445f38bf4db94f1a9ec771173a29e8" );
20518 
20519  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20520  if( 0 == 0 )
20521  {
20522  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20523 
20524  if( strcmp( "FAIL", "FAIL" ) == 0 )
20525  {
20526  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20527  }
20528  else
20529  {
20530  hexify( dst_str, output, pt_len );
20531 
20532  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20533  }
20534  }
20535  }
20536  FCT_TEST_END();
20537 
20538 
20539  FCT_TEST_BGN(gcm_nist_validation_aes_25612800120_0)
20540  {
20541  unsigned char key_str[128];
20542  unsigned char src_str[128];
20543  unsigned char dst_str[257];
20544  unsigned char iv_str[128];
20545  unsigned char add_str[128];
20546  unsigned char tag_str[128];
20547  unsigned char output[128];
20548  gcm_context ctx;
20549  unsigned int key_len;
20550  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
20551  int ret;
20552 
20553  memset(key_str, 0x00, 128);
20554  memset(src_str, 0x00, 128);
20555  memset(dst_str, 0x00, 257);
20556  memset(iv_str, 0x00, 128);
20557  memset(add_str, 0x00, 128);
20558  memset(tag_str, 0x00, 128);
20559  memset(output, 0x00, 128);
20560 
20561  key_len = unhexify( key_str, "7ca68e300534a90a7a87ca9906e4ac614a6aa51f769b6e6129753a4f83d10317" );
20562  pt_len = unhexify( src_str, "" );
20563  iv_len = unhexify( iv_str, "45e6b23f8b3feefd4b0ea06880b2c324" );
20564  add_len = unhexify( add_str, "" );
20565  unhexify( tag_str, "6c0a1c9c2cf5a40407bfa1d5958612" );
20566 
20567  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20568  if( 0 == 0 )
20569  {
20570  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20571 
20572  if( strcmp( "FAIL", "FAIL" ) == 0 )
20573  {
20574  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20575  }
20576  else
20577  {
20578  hexify( dst_str, output, pt_len );
20579 
20580  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20581  }
20582  }
20583  }
20584  FCT_TEST_END();
20585 
20586 
20587  FCT_TEST_BGN(gcm_nist_validation_aes_25612800120_1)
20588  {
20589  unsigned char key_str[128];
20590  unsigned char src_str[128];
20591  unsigned char dst_str[257];
20592  unsigned char iv_str[128];
20593  unsigned char add_str[128];
20594  unsigned char tag_str[128];
20595  unsigned char output[128];
20596  gcm_context ctx;
20597  unsigned int key_len;
20598  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
20599  int ret;
20600 
20601  memset(key_str, 0x00, 128);
20602  memset(src_str, 0x00, 128);
20603  memset(dst_str, 0x00, 257);
20604  memset(iv_str, 0x00, 128);
20605  memset(add_str, 0x00, 128);
20606  memset(tag_str, 0x00, 128);
20607  memset(output, 0x00, 128);
20608 
20609  key_len = unhexify( key_str, "a2b7cd693239bbc93599d3d12c9876e7303b227b8ae718e2c62e689e1fd62903" );
20610  pt_len = unhexify( src_str, "" );
20611  iv_len = unhexify( iv_str, "548c9c8fcc16416a9d2b35c29f0dacb3" );
20612  add_len = unhexify( add_str, "" );
20613  unhexify( tag_str, "3aa21f221266e7773eeba4440d1d01" );
20614 
20615  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20616  if( 0 == 0 )
20617  {
20618  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20619 
20620  if( strcmp( "FAIL", "" ) == 0 )
20621  {
20622  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20623  }
20624  else
20625  {
20626  hexify( dst_str, output, pt_len );
20627 
20628  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
20629  }
20630  }
20631  }
20632  FCT_TEST_END();
20633 
20634 
20635  FCT_TEST_BGN(gcm_nist_validation_aes_25612800120_2)
20636  {
20637  unsigned char key_str[128];
20638  unsigned char src_str[128];
20639  unsigned char dst_str[257];
20640  unsigned char iv_str[128];
20641  unsigned char add_str[128];
20642  unsigned char tag_str[128];
20643  unsigned char output[128];
20644  gcm_context ctx;
20645  unsigned int key_len;
20646  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
20647  int ret;
20648 
20649  memset(key_str, 0x00, 128);
20650  memset(src_str, 0x00, 128);
20651  memset(dst_str, 0x00, 257);
20652  memset(iv_str, 0x00, 128);
20653  memset(add_str, 0x00, 128);
20654  memset(tag_str, 0x00, 128);
20655  memset(output, 0x00, 128);
20656 
20657  key_len = unhexify( key_str, "156b854beb0c276a5e724f5da72f0d1ca4ae7cbd5f93a2257d95c2e5bfd78ad4" );
20658  pt_len = unhexify( src_str, "" );
20659  iv_len = unhexify( iv_str, "a5129e2530f47bcad42fc5774ee09fe7" );
20660  add_len = unhexify( add_str, "" );
20661  unhexify( tag_str, "6bb09ed183527c5d5ed46f568af35f" );
20662 
20663  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20664  if( 0 == 0 )
20665  {
20666  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20667 
20668  if( strcmp( "FAIL", "FAIL" ) == 0 )
20669  {
20670  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20671  }
20672  else
20673  {
20674  hexify( dst_str, output, pt_len );
20675 
20676  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20677  }
20678  }
20679  }
20680  FCT_TEST_END();
20681 
20682 
20683  FCT_TEST_BGN(gcm_nist_validation_aes_25612800112_0)
20684  {
20685  unsigned char key_str[128];
20686  unsigned char src_str[128];
20687  unsigned char dst_str[257];
20688  unsigned char iv_str[128];
20689  unsigned char add_str[128];
20690  unsigned char tag_str[128];
20691  unsigned char output[128];
20692  gcm_context ctx;
20693  unsigned int key_len;
20694  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
20695  int ret;
20696 
20697  memset(key_str, 0x00, 128);
20698  memset(src_str, 0x00, 128);
20699  memset(dst_str, 0x00, 257);
20700  memset(iv_str, 0x00, 128);
20701  memset(add_str, 0x00, 128);
20702  memset(tag_str, 0x00, 128);
20703  memset(output, 0x00, 128);
20704 
20705  key_len = unhexify( key_str, "d824330c60141264e1f709d63227a9a731bcc42b4adec1d8f0161b10b4fdb2ab" );
20706  pt_len = unhexify( src_str, "" );
20707  iv_len = unhexify( iv_str, "c5afaa45312c64ab3c3cf9d6c4e0cc47" );
20708  add_len = unhexify( add_str, "" );
20709  unhexify( tag_str, "55952a01eee29d8a1734bbdf3f8f" );
20710 
20711  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20712  if( 0 == 0 )
20713  {
20714  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20715 
20716  if( strcmp( "FAIL", "" ) == 0 )
20717  {
20718  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20719  }
20720  else
20721  {
20722  hexify( dst_str, output, pt_len );
20723 
20724  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
20725  }
20726  }
20727  }
20728  FCT_TEST_END();
20729 
20730 
20731  FCT_TEST_BGN(gcm_nist_validation_aes_25612800112_1)
20732  {
20733  unsigned char key_str[128];
20734  unsigned char src_str[128];
20735  unsigned char dst_str[257];
20736  unsigned char iv_str[128];
20737  unsigned char add_str[128];
20738  unsigned char tag_str[128];
20739  unsigned char output[128];
20740  gcm_context ctx;
20741  unsigned int key_len;
20742  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
20743  int ret;
20744 
20745  memset(key_str, 0x00, 128);
20746  memset(src_str, 0x00, 128);
20747  memset(dst_str, 0x00, 257);
20748  memset(iv_str, 0x00, 128);
20749  memset(add_str, 0x00, 128);
20750  memset(tag_str, 0x00, 128);
20751  memset(output, 0x00, 128);
20752 
20753  key_len = unhexify( key_str, "b5517589948d8aea778df6fd66c17a170d327f69e504f0a4bd504c4286a9f578" );
20754  pt_len = unhexify( src_str, "" );
20755  iv_len = unhexify( iv_str, "6404b111c6289eefa0d88ed6117bb730" );
20756  add_len = unhexify( add_str, "" );
20757  unhexify( tag_str, "637f82e592831531a8e877adfc2c" );
20758 
20759  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20760  if( 0 == 0 )
20761  {
20762  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20763 
20764  if( strcmp( "FAIL", "FAIL" ) == 0 )
20765  {
20766  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20767  }
20768  else
20769  {
20770  hexify( dst_str, output, pt_len );
20771 
20772  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20773  }
20774  }
20775  }
20776  FCT_TEST_END();
20777 
20778 
20779  FCT_TEST_BGN(gcm_nist_validation_aes_25612800112_2)
20780  {
20781  unsigned char key_str[128];
20782  unsigned char src_str[128];
20783  unsigned char dst_str[257];
20784  unsigned char iv_str[128];
20785  unsigned char add_str[128];
20786  unsigned char tag_str[128];
20787  unsigned char output[128];
20788  gcm_context ctx;
20789  unsigned int key_len;
20790  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
20791  int ret;
20792 
20793  memset(key_str, 0x00, 128);
20794  memset(src_str, 0x00, 128);
20795  memset(dst_str, 0x00, 257);
20796  memset(iv_str, 0x00, 128);
20797  memset(add_str, 0x00, 128);
20798  memset(tag_str, 0x00, 128);
20799  memset(output, 0x00, 128);
20800 
20801  key_len = unhexify( key_str, "f6137b2bcbd327fbcc7f313efa10f6ffaed30e4782e222e1225c87103fcae905" );
20802  pt_len = unhexify( src_str, "" );
20803  iv_len = unhexify( iv_str, "3b87b08337a82272b192bd067e3245ec" );
20804  add_len = unhexify( add_str, "" );
20805  unhexify( tag_str, "1f2dda372f20ffddd9dd4810e05f" );
20806 
20807  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20808  if( 0 == 0 )
20809  {
20810  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20811 
20812  if( strcmp( "FAIL", "" ) == 0 )
20813  {
20814  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20815  }
20816  else
20817  {
20818  hexify( dst_str, output, pt_len );
20819 
20820  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
20821  }
20822  }
20823  }
20824  FCT_TEST_END();
20825 
20826 
20827  FCT_TEST_BGN(gcm_nist_validation_aes_25612800104_0)
20828  {
20829  unsigned char key_str[128];
20830  unsigned char src_str[128];
20831  unsigned char dst_str[257];
20832  unsigned char iv_str[128];
20833  unsigned char add_str[128];
20834  unsigned char tag_str[128];
20835  unsigned char output[128];
20836  gcm_context ctx;
20837  unsigned int key_len;
20838  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
20839  int ret;
20840 
20841  memset(key_str, 0x00, 128);
20842  memset(src_str, 0x00, 128);
20843  memset(dst_str, 0x00, 257);
20844  memset(iv_str, 0x00, 128);
20845  memset(add_str, 0x00, 128);
20846  memset(tag_str, 0x00, 128);
20847  memset(output, 0x00, 128);
20848 
20849  key_len = unhexify( key_str, "b5e70d1b78e931abf44bba3f937dbc344858516a8a8afe605818dc67d0c3e4c4" );
20850  pt_len = unhexify( src_str, "" );
20851  iv_len = unhexify( iv_str, "58e70095c6f3a0cda2cdc7775e2f383d" );
20852  add_len = unhexify( add_str, "" );
20853  unhexify( tag_str, "1763573f7dab8b46bc177e6147" );
20854 
20855  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20856  if( 0 == 0 )
20857  {
20858  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20859 
20860  if( strcmp( "FAIL", "" ) == 0 )
20861  {
20862  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20863  }
20864  else
20865  {
20866  hexify( dst_str, output, pt_len );
20867 
20868  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
20869  }
20870  }
20871  }
20872  FCT_TEST_END();
20873 
20874 
20875  FCT_TEST_BGN(gcm_nist_validation_aes_25612800104_1)
20876  {
20877  unsigned char key_str[128];
20878  unsigned char src_str[128];
20879  unsigned char dst_str[257];
20880  unsigned char iv_str[128];
20881  unsigned char add_str[128];
20882  unsigned char tag_str[128];
20883  unsigned char output[128];
20884  gcm_context ctx;
20885  unsigned int key_len;
20886  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
20887  int ret;
20888 
20889  memset(key_str, 0x00, 128);
20890  memset(src_str, 0x00, 128);
20891  memset(dst_str, 0x00, 257);
20892  memset(iv_str, 0x00, 128);
20893  memset(add_str, 0x00, 128);
20894  memset(tag_str, 0x00, 128);
20895  memset(output, 0x00, 128);
20896 
20897  key_len = unhexify( key_str, "90de0c047d1dd01d521f2dedec7eb81bc0ace7a5a693a7869eaafbb6e725ad7b" );
20898  pt_len = unhexify( src_str, "" );
20899  iv_len = unhexify( iv_str, "d565c9cdfb5d0a25c4083b51729626bd" );
20900  add_len = unhexify( add_str, "" );
20901  unhexify( tag_str, "78738d3e9f5e00b49635ac9a2d" );
20902 
20903  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20904  if( 0 == 0 )
20905  {
20906  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20907 
20908  if( strcmp( "FAIL", "FAIL" ) == 0 )
20909  {
20910  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20911  }
20912  else
20913  {
20914  hexify( dst_str, output, pt_len );
20915 
20916  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20917  }
20918  }
20919  }
20920  FCT_TEST_END();
20921 
20922 
20923  FCT_TEST_BGN(gcm_nist_validation_aes_25612800104_2)
20924  {
20925  unsigned char key_str[128];
20926  unsigned char src_str[128];
20927  unsigned char dst_str[257];
20928  unsigned char iv_str[128];
20929  unsigned char add_str[128];
20930  unsigned char tag_str[128];
20931  unsigned char output[128];
20932  gcm_context ctx;
20933  unsigned int key_len;
20934  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
20935  int ret;
20936 
20937  memset(key_str, 0x00, 128);
20938  memset(src_str, 0x00, 128);
20939  memset(dst_str, 0x00, 257);
20940  memset(iv_str, 0x00, 128);
20941  memset(add_str, 0x00, 128);
20942  memset(tag_str, 0x00, 128);
20943  memset(output, 0x00, 128);
20944 
20945  key_len = unhexify( key_str, "c43e8dbeafb079692483a9fcbab964b76fccca6ca99e1388a1aa9bf78dfd2f02" );
20946  pt_len = unhexify( src_str, "" );
20947  iv_len = unhexify( iv_str, "f2bd4fe0d30c0e8d429cac90c8a7b1c8" );
20948  add_len = unhexify( add_str, "" );
20949  unhexify( tag_str, "ea7b52490943380ccc902ca5ae" );
20950 
20951  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
20952  if( 0 == 0 )
20953  {
20954  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
20955 
20956  if( strcmp( "FAIL", "FAIL" ) == 0 )
20957  {
20958  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
20959  }
20960  else
20961  {
20962  hexify( dst_str, output, pt_len );
20963 
20964  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
20965  }
20966  }
20967  }
20968  FCT_TEST_END();
20969 
20970 
20971  FCT_TEST_BGN(gcm_nist_validation_aes_2561280096_0)
20972  {
20973  unsigned char key_str[128];
20974  unsigned char src_str[128];
20975  unsigned char dst_str[257];
20976  unsigned char iv_str[128];
20977  unsigned char add_str[128];
20978  unsigned char tag_str[128];
20979  unsigned char output[128];
20980  gcm_context ctx;
20981  unsigned int key_len;
20982  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
20983  int ret;
20984 
20985  memset(key_str, 0x00, 128);
20986  memset(src_str, 0x00, 128);
20987  memset(dst_str, 0x00, 257);
20988  memset(iv_str, 0x00, 128);
20989  memset(add_str, 0x00, 128);
20990  memset(tag_str, 0x00, 128);
20991  memset(output, 0x00, 128);
20992 
20993  key_len = unhexify( key_str, "13540919fdb95559e37b535a427efeee334309e34c4608459e204d931b8087e7" );
20994  pt_len = unhexify( src_str, "" );
20995  iv_len = unhexify( iv_str, "c993c1802df0f075ce92963eb9bff9bd" );
20996  add_len = unhexify( add_str, "" );
20997  unhexify( tag_str, "edfab013213591beb53e6419" );
20998 
20999  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21000  if( 0 == 0 )
21001  {
21002  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21003 
21004  if( strcmp( "FAIL", "FAIL" ) == 0 )
21005  {
21006  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21007  }
21008  else
21009  {
21010  hexify( dst_str, output, pt_len );
21011 
21012  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21013  }
21014  }
21015  }
21016  FCT_TEST_END();
21017 
21018 
21019  FCT_TEST_BGN(gcm_nist_validation_aes_2561280096_1)
21020  {
21021  unsigned char key_str[128];
21022  unsigned char src_str[128];
21023  unsigned char dst_str[257];
21024  unsigned char iv_str[128];
21025  unsigned char add_str[128];
21026  unsigned char tag_str[128];
21027  unsigned char output[128];
21028  gcm_context ctx;
21029  unsigned int key_len;
21030  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
21031  int ret;
21032 
21033  memset(key_str, 0x00, 128);
21034  memset(src_str, 0x00, 128);
21035  memset(dst_str, 0x00, 257);
21036  memset(iv_str, 0x00, 128);
21037  memset(add_str, 0x00, 128);
21038  memset(tag_str, 0x00, 128);
21039  memset(output, 0x00, 128);
21040 
21041  key_len = unhexify( key_str, "2a7b2e07c148ff0f627ae28c241a395876bbed0c20f3fd637330e986db025714" );
21042  pt_len = unhexify( src_str, "" );
21043  iv_len = unhexify( iv_str, "8f7e1621c2227839da4ea60548290ffa" );
21044  add_len = unhexify( add_str, "" );
21045  unhexify( tag_str, "f9da62f59c080160ec30b43d" );
21046 
21047  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21048  if( 0 == 0 )
21049  {
21050  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21051 
21052  if( strcmp( "FAIL", "FAIL" ) == 0 )
21053  {
21054  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21055  }
21056  else
21057  {
21058  hexify( dst_str, output, pt_len );
21059 
21060  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21061  }
21062  }
21063  }
21064  FCT_TEST_END();
21065 
21066 
21067  FCT_TEST_BGN(gcm_nist_validation_aes_2561280096_2)
21068  {
21069  unsigned char key_str[128];
21070  unsigned char src_str[128];
21071  unsigned char dst_str[257];
21072  unsigned char iv_str[128];
21073  unsigned char add_str[128];
21074  unsigned char tag_str[128];
21075  unsigned char output[128];
21076  gcm_context ctx;
21077  unsigned int key_len;
21078  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
21079  int ret;
21080 
21081  memset(key_str, 0x00, 128);
21082  memset(src_str, 0x00, 128);
21083  memset(dst_str, 0x00, 257);
21084  memset(iv_str, 0x00, 128);
21085  memset(add_str, 0x00, 128);
21086  memset(tag_str, 0x00, 128);
21087  memset(output, 0x00, 128);
21088 
21089  key_len = unhexify( key_str, "b3e7837a75b38ae6d4299a1ae4af3c2460dfca558708de0874d6b1a5689b8360" );
21090  pt_len = unhexify( src_str, "" );
21091  iv_len = unhexify( iv_str, "05d363b2452beff4b47afb052ac3c973" );
21092  add_len = unhexify( add_str, "" );
21093  unhexify( tag_str, "6b4a16d1ea1c21b22bdcb235" );
21094 
21095  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21096  if( 0 == 0 )
21097  {
21098  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21099 
21100  if( strcmp( "FAIL", "FAIL" ) == 0 )
21101  {
21102  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21103  }
21104  else
21105  {
21106  hexify( dst_str, output, pt_len );
21107 
21108  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21109  }
21110  }
21111  }
21112  FCT_TEST_END();
21113 
21114 
21115  FCT_TEST_BGN(gcm_nist_validation_aes_2561280064_0)
21116  {
21117  unsigned char key_str[128];
21118  unsigned char src_str[128];
21119  unsigned char dst_str[257];
21120  unsigned char iv_str[128];
21121  unsigned char add_str[128];
21122  unsigned char tag_str[128];
21123  unsigned char output[128];
21124  gcm_context ctx;
21125  unsigned int key_len;
21126  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
21127  int ret;
21128 
21129  memset(key_str, 0x00, 128);
21130  memset(src_str, 0x00, 128);
21131  memset(dst_str, 0x00, 257);
21132  memset(iv_str, 0x00, 128);
21133  memset(add_str, 0x00, 128);
21134  memset(tag_str, 0x00, 128);
21135  memset(output, 0x00, 128);
21136 
21137  key_len = unhexify( key_str, "9df3ccd95f7570f6ecf5e5329dcb79bcd46cbcf083fe03aa8f5bd0f645c6a607" );
21138  pt_len = unhexify( src_str, "" );
21139  iv_len = unhexify( iv_str, "774f4e70a7577b5101c0c3d019655d3e" );
21140  add_len = unhexify( add_str, "" );
21141  unhexify( tag_str, "98ff89a8e28c03fd" );
21142 
21143  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21144  if( 0 == 0 )
21145  {
21146  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21147 
21148  if( strcmp( "FAIL", "" ) == 0 )
21149  {
21150  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21151  }
21152  else
21153  {
21154  hexify( dst_str, output, pt_len );
21155 
21156  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
21157  }
21158  }
21159  }
21160  FCT_TEST_END();
21161 
21162 
21163  FCT_TEST_BGN(gcm_nist_validation_aes_2561280064_1)
21164  {
21165  unsigned char key_str[128];
21166  unsigned char src_str[128];
21167  unsigned char dst_str[257];
21168  unsigned char iv_str[128];
21169  unsigned char add_str[128];
21170  unsigned char tag_str[128];
21171  unsigned char output[128];
21172  gcm_context ctx;
21173  unsigned int key_len;
21174  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
21175  int ret;
21176 
21177  memset(key_str, 0x00, 128);
21178  memset(src_str, 0x00, 128);
21179  memset(dst_str, 0x00, 257);
21180  memset(iv_str, 0x00, 128);
21181  memset(add_str, 0x00, 128);
21182  memset(tag_str, 0x00, 128);
21183  memset(output, 0x00, 128);
21184 
21185  key_len = unhexify( key_str, "1c7123e2e8d3774c8f1bdbb2272f19129e04f29b4351ae19c3b9d24e6ea1fe87" );
21186  pt_len = unhexify( src_str, "" );
21187  iv_len = unhexify( iv_str, "99f25cebd6cfa7f41390b42df6a65f48" );
21188  add_len = unhexify( add_str, "" );
21189  unhexify( tag_str, "8e14a0a4853a156a" );
21190 
21191  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21192  if( 0 == 0 )
21193  {
21194  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21195 
21196  if( strcmp( "FAIL", "FAIL" ) == 0 )
21197  {
21198  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21199  }
21200  else
21201  {
21202  hexify( dst_str, output, pt_len );
21203 
21204  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21205  }
21206  }
21207  }
21208  FCT_TEST_END();
21209 
21210 
21211  FCT_TEST_BGN(gcm_nist_validation_aes_2561280064_2)
21212  {
21213  unsigned char key_str[128];
21214  unsigned char src_str[128];
21215  unsigned char dst_str[257];
21216  unsigned char iv_str[128];
21217  unsigned char add_str[128];
21218  unsigned char tag_str[128];
21219  unsigned char output[128];
21220  gcm_context ctx;
21221  unsigned int key_len;
21222  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
21223  int ret;
21224 
21225  memset(key_str, 0x00, 128);
21226  memset(src_str, 0x00, 128);
21227  memset(dst_str, 0x00, 257);
21228  memset(iv_str, 0x00, 128);
21229  memset(add_str, 0x00, 128);
21230  memset(tag_str, 0x00, 128);
21231  memset(output, 0x00, 128);
21232 
21233  key_len = unhexify( key_str, "490090323e9257517e2453469caa3414045cacb4d05d5cebc6b9c06fa6d19291" );
21234  pt_len = unhexify( src_str, "" );
21235  iv_len = unhexify( iv_str, "c1beff1ff6cdd62339aa21149c4da1e6" );
21236  add_len = unhexify( add_str, "" );
21237  unhexify( tag_str, "f998d7c08d609b3a" );
21238 
21239  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21240  if( 0 == 0 )
21241  {
21242  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21243 
21244  if( strcmp( "FAIL", "" ) == 0 )
21245  {
21246  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21247  }
21248  else
21249  {
21250  hexify( dst_str, output, pt_len );
21251 
21252  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
21253  }
21254  }
21255  }
21256  FCT_TEST_END();
21257 
21258 
21259  FCT_TEST_BGN(gcm_nist_validation_aes_2561280032_0)
21260  {
21261  unsigned char key_str[128];
21262  unsigned char src_str[128];
21263  unsigned char dst_str[257];
21264  unsigned char iv_str[128];
21265  unsigned char add_str[128];
21266  unsigned char tag_str[128];
21267  unsigned char output[128];
21268  gcm_context ctx;
21269  unsigned int key_len;
21270  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
21271  int ret;
21272 
21273  memset(key_str, 0x00, 128);
21274  memset(src_str, 0x00, 128);
21275  memset(dst_str, 0x00, 257);
21276  memset(iv_str, 0x00, 128);
21277  memset(add_str, 0x00, 128);
21278  memset(tag_str, 0x00, 128);
21279  memset(output, 0x00, 128);
21280 
21281  key_len = unhexify( key_str, "360e48dd38d9e7f5bf29a2994ab5b3c9c70247102d94049ae791850807a4c845" );
21282  pt_len = unhexify( src_str, "" );
21283  iv_len = unhexify( iv_str, "88126c350dfc079c569210ee44a0e31a" );
21284  add_len = unhexify( add_str, "" );
21285  unhexify( tag_str, "f2ebe5e4" );
21286 
21287  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21288  if( 0 == 0 )
21289  {
21290  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21291 
21292  if( strcmp( "FAIL", "FAIL" ) == 0 )
21293  {
21294  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21295  }
21296  else
21297  {
21298  hexify( dst_str, output, pt_len );
21299 
21300  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21301  }
21302  }
21303  }
21304  FCT_TEST_END();
21305 
21306 
21307  FCT_TEST_BGN(gcm_nist_validation_aes_2561280032_1)
21308  {
21309  unsigned char key_str[128];
21310  unsigned char src_str[128];
21311  unsigned char dst_str[257];
21312  unsigned char iv_str[128];
21313  unsigned char add_str[128];
21314  unsigned char tag_str[128];
21315  unsigned char output[128];
21316  gcm_context ctx;
21317  unsigned int key_len;
21318  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
21319  int ret;
21320 
21321  memset(key_str, 0x00, 128);
21322  memset(src_str, 0x00, 128);
21323  memset(dst_str, 0x00, 257);
21324  memset(iv_str, 0x00, 128);
21325  memset(add_str, 0x00, 128);
21326  memset(tag_str, 0x00, 128);
21327  memset(output, 0x00, 128);
21328 
21329  key_len = unhexify( key_str, "1562b32e4dd843edaf4474b62cadd8f46d50461f5b22c9f1a8eae7367d35d71b" );
21330  pt_len = unhexify( src_str, "" );
21331  iv_len = unhexify( iv_str, "af29fdb96f726c76f76c473c873b9e08" );
21332  add_len = unhexify( add_str, "" );
21333  unhexify( tag_str, "13fd6dfd" );
21334 
21335  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21336  if( 0 == 0 )
21337  {
21338  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21339 
21340  if( strcmp( "FAIL", "FAIL" ) == 0 )
21341  {
21342  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21343  }
21344  else
21345  {
21346  hexify( dst_str, output, pt_len );
21347 
21348  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21349  }
21350  }
21351  }
21352  FCT_TEST_END();
21353 
21354 
21355  FCT_TEST_BGN(gcm_nist_validation_aes_2561280032_2)
21356  {
21357  unsigned char key_str[128];
21358  unsigned char src_str[128];
21359  unsigned char dst_str[257];
21360  unsigned char iv_str[128];
21361  unsigned char add_str[128];
21362  unsigned char tag_str[128];
21363  unsigned char output[128];
21364  gcm_context ctx;
21365  unsigned int key_len;
21366  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
21367  int ret;
21368 
21369  memset(key_str, 0x00, 128);
21370  memset(src_str, 0x00, 128);
21371  memset(dst_str, 0x00, 257);
21372  memset(iv_str, 0x00, 128);
21373  memset(add_str, 0x00, 128);
21374  memset(tag_str, 0x00, 128);
21375  memset(output, 0x00, 128);
21376 
21377  key_len = unhexify( key_str, "d5160d0c98ffcb1c26aad755f67589000e2bb25fa940e6b1d81d780f421353d9" );
21378  pt_len = unhexify( src_str, "" );
21379  iv_len = unhexify( iv_str, "1552604763453b48a57cea1aed8113f4" );
21380  add_len = unhexify( add_str, "" );
21381  unhexify( tag_str, "660c5175" );
21382 
21383  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21384  if( 0 == 0 )
21385  {
21386  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21387 
21388  if( strcmp( "FAIL", "" ) == 0 )
21389  {
21390  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21391  }
21392  else
21393  {
21394  hexify( dst_str, output, pt_len );
21395 
21396  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
21397  }
21398  }
21399  }
21400  FCT_TEST_END();
21401 
21402 
21403  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024128_0)
21404  {
21405  unsigned char key_str[128];
21406  unsigned char src_str[128];
21407  unsigned char dst_str[257];
21408  unsigned char iv_str[128];
21409  unsigned char add_str[128];
21410  unsigned char tag_str[128];
21411  unsigned char output[128];
21412  gcm_context ctx;
21413  unsigned int key_len;
21414  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
21415  int ret;
21416 
21417  memset(key_str, 0x00, 128);
21418  memset(src_str, 0x00, 128);
21419  memset(dst_str, 0x00, 257);
21420  memset(iv_str, 0x00, 128);
21421  memset(add_str, 0x00, 128);
21422  memset(tag_str, 0x00, 128);
21423  memset(output, 0x00, 128);
21424 
21425  key_len = unhexify( key_str, "c3a3ea3a097c0c2b3a4cb78462d87fd5a8f348687c4150e9d3354b388ab13d17" );
21426  pt_len = unhexify( src_str, "" );
21427  iv_len = unhexify( iv_str, "f77945979241fb3a454d8e3da193e169" );
21428  add_len = unhexify( add_str, "a69bac31241a2c07d3f7e331b77f662b1e67ccb81c07f52578b01f5785de9437f02eb7627ca7b9af09c1cb428fe93d6deb31f4d6dd2f0729f87480bdeb92d985de1aaad4bcebc6fbad83bede9a5dd1ca6a15bf5d8a96d4edb5bee1f7d195e9b2e5fb2221a596d69f257c18a143eda870e22d3f2ed20c9b3b0d8c8a229c462fff" );
21429  unhexify( tag_str, "6b4b1a84f49befe3897d59ce85598a9f" );
21430 
21431  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21432  if( 0 == 0 )
21433  {
21434  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21435 
21436  if( strcmp( "FAIL", "" ) == 0 )
21437  {
21438  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21439  }
21440  else
21441  {
21442  hexify( dst_str, output, pt_len );
21443 
21444  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
21445  }
21446  }
21447  }
21448  FCT_TEST_END();
21449 
21450 
21451  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024128_1)
21452  {
21453  unsigned char key_str[128];
21454  unsigned char src_str[128];
21455  unsigned char dst_str[257];
21456  unsigned char iv_str[128];
21457  unsigned char add_str[128];
21458  unsigned char tag_str[128];
21459  unsigned char output[128];
21460  gcm_context ctx;
21461  unsigned int key_len;
21462  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
21463  int ret;
21464 
21465  memset(key_str, 0x00, 128);
21466  memset(src_str, 0x00, 128);
21467  memset(dst_str, 0x00, 257);
21468  memset(iv_str, 0x00, 128);
21469  memset(add_str, 0x00, 128);
21470  memset(tag_str, 0x00, 128);
21471  memset(output, 0x00, 128);
21472 
21473  key_len = unhexify( key_str, "e1626327d987342cba5c8c63b75b4ed65463a2b9c831f4f9f80325fa867d1d73" );
21474  pt_len = unhexify( src_str, "" );
21475  iv_len = unhexify( iv_str, "4e25800deab7ecec2a2311f8fb44eb7d" );
21476  add_len = unhexify( add_str, "ebaffd558f24dae03117c69ac4b2b4aaeaffe7e0e7599eaba678bfce23a9914dc9f80b69f4a1c837a5544cba08064a8f924064cba4d783623600d8b61837a08b4e0d4eb9218c29bc3edb8dd0e78c1534ab52331f949b09b25fbf73bece7054179817bc15b4e869c5df1af569c2b19cb6d060855be9a15f2cf497c168c4e683f2" );
21477  unhexify( tag_str, "8faa0ffb91311a1a2827b86fec01788d" );
21478 
21479  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21480  if( 0 == 0 )
21481  {
21482  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21483 
21484  if( strcmp( "FAIL", "FAIL" ) == 0 )
21485  {
21486  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21487  }
21488  else
21489  {
21490  hexify( dst_str, output, pt_len );
21491 
21492  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21493  }
21494  }
21495  }
21496  FCT_TEST_END();
21497 
21498 
21499  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024128_2)
21500  {
21501  unsigned char key_str[128];
21502  unsigned char src_str[128];
21503  unsigned char dst_str[257];
21504  unsigned char iv_str[128];
21505  unsigned char add_str[128];
21506  unsigned char tag_str[128];
21507  unsigned char output[128];
21508  gcm_context ctx;
21509  unsigned int key_len;
21510  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
21511  int ret;
21512 
21513  memset(key_str, 0x00, 128);
21514  memset(src_str, 0x00, 128);
21515  memset(dst_str, 0x00, 257);
21516  memset(iv_str, 0x00, 128);
21517  memset(add_str, 0x00, 128);
21518  memset(tag_str, 0x00, 128);
21519  memset(output, 0x00, 128);
21520 
21521  key_len = unhexify( key_str, "938da64b837275b0c80c442bdf2301aa75e387fe65a775d10a8ec840f62ff429" );
21522  pt_len = unhexify( src_str, "" );
21523  iv_len = unhexify( iv_str, "dec6adeb60216cbb8a6c3afba49fa201" );
21524  add_len = unhexify( add_str, "4ac144bd95f405649444f01ab67ef3e4c0a54fdbd933b6ba00518c79db45c22c90030c45aadcfdb53ec8199be0cbb22dbb9ab938a871f4b3b0c98ed32590a051abb946c42726b3e9701f183b2092985e3457943a6350fbcaece2e6b111b179ea3fd10ac080a577a1481785111d5f294bc28519c470ff94392a51a2c40a42d8b5" );
21525  unhexify( tag_str, "2211ca91a809adb8cf55f001745c0563" );
21526 
21527  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21528  if( 0 == 0 )
21529  {
21530  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21531 
21532  if( strcmp( "FAIL", "FAIL" ) == 0 )
21533  {
21534  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21535  }
21536  else
21537  {
21538  hexify( dst_str, output, pt_len );
21539 
21540  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21541  }
21542  }
21543  }
21544  FCT_TEST_END();
21545 
21546 
21547  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024120_0)
21548  {
21549  unsigned char key_str[128];
21550  unsigned char src_str[128];
21551  unsigned char dst_str[257];
21552  unsigned char iv_str[128];
21553  unsigned char add_str[128];
21554  unsigned char tag_str[128];
21555  unsigned char output[128];
21556  gcm_context ctx;
21557  unsigned int key_len;
21558  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
21559  int ret;
21560 
21561  memset(key_str, 0x00, 128);
21562  memset(src_str, 0x00, 128);
21563  memset(dst_str, 0x00, 257);
21564  memset(iv_str, 0x00, 128);
21565  memset(add_str, 0x00, 128);
21566  memset(tag_str, 0x00, 128);
21567  memset(output, 0x00, 128);
21568 
21569  key_len = unhexify( key_str, "e2436484ea1f454d6451ad8dbd1574b208d7a3ab4fa34869299b85c24348b43d" );
21570  pt_len = unhexify( src_str, "" );
21571  iv_len = unhexify( iv_str, "97040d2ec094fe1c64fa35b35b7451a7" );
21572  add_len = unhexify( add_str, "bc198677513ce0e66697dfe52b22315fa5d8f92042f34cc9f373a01f94607df1a599132f60af010ed9b5e52162dd7b162912b68b11700e08f5fdafd84d10f760fc05ec97c05b83e55155194f399594015b90a19c04fb992e228940fe1b54ba59c4bb8318b33cc0df1cb1d71c389473dfb3eefabfe269ca95db59a7bc0201c253" );
21573  unhexify( tag_str, "2e080ba16011e22a779da1922345c2" );
21574 
21575  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21576  if( 0 == 0 )
21577  {
21578  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21579 
21580  if( strcmp( "FAIL", "" ) == 0 )
21581  {
21582  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21583  }
21584  else
21585  {
21586  hexify( dst_str, output, pt_len );
21587 
21588  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
21589  }
21590  }
21591  }
21592  FCT_TEST_END();
21593 
21594 
21595  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024120_1)
21596  {
21597  unsigned char key_str[128];
21598  unsigned char src_str[128];
21599  unsigned char dst_str[257];
21600  unsigned char iv_str[128];
21601  unsigned char add_str[128];
21602  unsigned char tag_str[128];
21603  unsigned char output[128];
21604  gcm_context ctx;
21605  unsigned int key_len;
21606  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
21607  int ret;
21608 
21609  memset(key_str, 0x00, 128);
21610  memset(src_str, 0x00, 128);
21611  memset(dst_str, 0x00, 257);
21612  memset(iv_str, 0x00, 128);
21613  memset(add_str, 0x00, 128);
21614  memset(tag_str, 0x00, 128);
21615  memset(output, 0x00, 128);
21616 
21617  key_len = unhexify( key_str, "7fb3fc72eb8a3aa5b102f90039f852cc3fd64f46915f5e49f1d9e02fe9cc13b1" );
21618  pt_len = unhexify( src_str, "" );
21619  iv_len = unhexify( iv_str, "f6120fea313362524917c53d90bafb4f" );
21620  add_len = unhexify( add_str, "60c2be7fbd15faf895fd19a9ce775fe2b183b45cffafe4fcbf50d421bea97347e41a9418cfa129b2dda63b889a70063010215dbe38c37feae18bc31b34f31b726f22177f2b4b9d648dd4aa80edfd12dafaee10baa83224354432d1cb62ccabe38bb8448d162cd0d30e988d2e1a2458ffdafaacbdff928756390f66dc60d7ea45" );
21621  unhexify( tag_str, "83de3f521fcfdaff902386f359e683" );
21622 
21623  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21624  if( 0 == 0 )
21625  {
21626  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21627 
21628  if( strcmp( "FAIL", "FAIL" ) == 0 )
21629  {
21630  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21631  }
21632  else
21633  {
21634  hexify( dst_str, output, pt_len );
21635 
21636  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21637  }
21638  }
21639  }
21640  FCT_TEST_END();
21641 
21642 
21643  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024120_2)
21644  {
21645  unsigned char key_str[128];
21646  unsigned char src_str[128];
21647  unsigned char dst_str[257];
21648  unsigned char iv_str[128];
21649  unsigned char add_str[128];
21650  unsigned char tag_str[128];
21651  unsigned char output[128];
21652  gcm_context ctx;
21653  unsigned int key_len;
21654  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
21655  int ret;
21656 
21657  memset(key_str, 0x00, 128);
21658  memset(src_str, 0x00, 128);
21659  memset(dst_str, 0x00, 257);
21660  memset(iv_str, 0x00, 128);
21661  memset(add_str, 0x00, 128);
21662  memset(tag_str, 0x00, 128);
21663  memset(output, 0x00, 128);
21664 
21665  key_len = unhexify( key_str, "697c96d80d0a3fa9af35b86f31fb71a17aed30ce841c79896bbc8863b3b3ee04" );
21666  pt_len = unhexify( src_str, "" );
21667  iv_len = unhexify( iv_str, "3a5163ec7e007061838d755ac219855e" );
21668  add_len = unhexify( add_str, "de50c12da63232768d5eb9920d49683b5b7114cb77448fa10b9d63552ec5d9c2eac94b375d11f944959f903bb20c696639b6e7f108ec1e873870098c631ddacb2c25268cfc26d2a4cacfb7dda7383374c5456bcf4daa887a887f4293f8caa14419472a8bf7ffd214dfb2743091238b6d1142b116c2b9f4360c6fe0015cd7de81" );
21669  unhexify( tag_str, "cd4542b26094a1c8e058648874f06f" );
21670 
21671  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21672  if( 0 == 0 )
21673  {
21674  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21675 
21676  if( strcmp( "FAIL", "FAIL" ) == 0 )
21677  {
21678  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21679  }
21680  else
21681  {
21682  hexify( dst_str, output, pt_len );
21683 
21684  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21685  }
21686  }
21687  }
21688  FCT_TEST_END();
21689 
21690 
21691  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024112_0)
21692  {
21693  unsigned char key_str[128];
21694  unsigned char src_str[128];
21695  unsigned char dst_str[257];
21696  unsigned char iv_str[128];
21697  unsigned char add_str[128];
21698  unsigned char tag_str[128];
21699  unsigned char output[128];
21700  gcm_context ctx;
21701  unsigned int key_len;
21702  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
21703  int ret;
21704 
21705  memset(key_str, 0x00, 128);
21706  memset(src_str, 0x00, 128);
21707  memset(dst_str, 0x00, 257);
21708  memset(iv_str, 0x00, 128);
21709  memset(add_str, 0x00, 128);
21710  memset(tag_str, 0x00, 128);
21711  memset(output, 0x00, 128);
21712 
21713  key_len = unhexify( key_str, "66c1d9ce3feb0e966c33e3fd542ec11cc32f18c2514b953103d32abcdc72633a" );
21714  pt_len = unhexify( src_str, "" );
21715  iv_len = unhexify( iv_str, "46fdb88fdde9b7d74e893802a0303256" );
21716  add_len = unhexify( add_str, "55d2f263d2e3cf0b390fce1dd1ebd5f666086f26e1ce2f08002bedbb810ada3922c6bfcf6a6adaa556e9e326c9766f02b3eb6e278da2fa3baa7dbdb6373be3c6ecfbe646b1a39e27c5a449db9b559e7ea3496366b8cdbca00ee7a3dea7fdfbea1665bbf58bd69bb961c33a0fd7d37b580b6a82804f394f9d5d4366772cee3115" );
21717  unhexify( tag_str, "96ca402b16b0f2cd0cdff77935d3" );
21718 
21719  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21720  if( 0 == 0 )
21721  {
21722  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21723 
21724  if( strcmp( "FAIL", "" ) == 0 )
21725  {
21726  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21727  }
21728  else
21729  {
21730  hexify( dst_str, output, pt_len );
21731 
21732  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
21733  }
21734  }
21735  }
21736  FCT_TEST_END();
21737 
21738 
21739  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024112_1)
21740  {
21741  unsigned char key_str[128];
21742  unsigned char src_str[128];
21743  unsigned char dst_str[257];
21744  unsigned char iv_str[128];
21745  unsigned char add_str[128];
21746  unsigned char tag_str[128];
21747  unsigned char output[128];
21748  gcm_context ctx;
21749  unsigned int key_len;
21750  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
21751  int ret;
21752 
21753  memset(key_str, 0x00, 128);
21754  memset(src_str, 0x00, 128);
21755  memset(dst_str, 0x00, 257);
21756  memset(iv_str, 0x00, 128);
21757  memset(add_str, 0x00, 128);
21758  memset(tag_str, 0x00, 128);
21759  memset(output, 0x00, 128);
21760 
21761  key_len = unhexify( key_str, "d7c949420dc9497232cd5810f316d11f9e85d36c430b5943ba79836d88c1eb92" );
21762  pt_len = unhexify( src_str, "" );
21763  iv_len = unhexify( iv_str, "7ef9788ff09cbeedd9569d49083a4097" );
21764  add_len = unhexify( add_str, "ca1de5cc3fcde2638eb72210e551e9c0e0a3f5570d5be83a9a4406b545d854bf17e75b9cd0f4c45722fbd71319a317b72a8798485e9316a1c8102432b83bc95af42f6d50700ba68f6f2e19b6af609b73ad643dfa43da94be32cc09b024e087c120e4d2c20f96f8e9ddfe7eae186a540a22131cedfe556d1ebd9306684e345fd1" );
21765  unhexify( tag_str, "8233588fca3ad1698d07b25fa3c4" );
21766 
21767  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21768  if( 0 == 0 )
21769  {
21770  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21771 
21772  if( strcmp( "FAIL", "" ) == 0 )
21773  {
21774  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21775  }
21776  else
21777  {
21778  hexify( dst_str, output, pt_len );
21779 
21780  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
21781  }
21782  }
21783  }
21784  FCT_TEST_END();
21785 
21786 
21787  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024112_2)
21788  {
21789  unsigned char key_str[128];
21790  unsigned char src_str[128];
21791  unsigned char dst_str[257];
21792  unsigned char iv_str[128];
21793  unsigned char add_str[128];
21794  unsigned char tag_str[128];
21795  unsigned char output[128];
21796  gcm_context ctx;
21797  unsigned int key_len;
21798  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
21799  int ret;
21800 
21801  memset(key_str, 0x00, 128);
21802  memset(src_str, 0x00, 128);
21803  memset(dst_str, 0x00, 257);
21804  memset(iv_str, 0x00, 128);
21805  memset(add_str, 0x00, 128);
21806  memset(tag_str, 0x00, 128);
21807  memset(output, 0x00, 128);
21808 
21809  key_len = unhexify( key_str, "6fe7c70815aa12326cdcbb2d2d3e088bbaaef98b730f87fe8510b33d30e12afe" );
21810  pt_len = unhexify( src_str, "" );
21811  iv_len = unhexify( iv_str, "e0253bd1f19e99a7f8848206fb8ac4a4" );
21812  add_len = unhexify( add_str, "397897eca4856f90d14c3cdfe1ad3cba47e23174ae2dab7d2a6320898584e03bffa3ffd526f416d7b3c579b0f3628744e36eebb5df519240c81d8bbbf5c5966519c5da083ab30a7aa42deae6180e517cdd764b7f77d19cc1a84141817758887a8d7265e7e62279b9d33cd2f1ba10fd54c6c96d4b8a5dbe2318fef629c8e2af0f" );
21813  unhexify( tag_str, "477b0a884d788d1905646bd66084" );
21814 
21815  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21816  if( 0 == 0 )
21817  {
21818  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21819 
21820  if( strcmp( "FAIL", "" ) == 0 )
21821  {
21822  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21823  }
21824  else
21825  {
21826  hexify( dst_str, output, pt_len );
21827 
21828  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
21829  }
21830  }
21831  }
21832  FCT_TEST_END();
21833 
21834 
21835  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024104_0)
21836  {
21837  unsigned char key_str[128];
21838  unsigned char src_str[128];
21839  unsigned char dst_str[257];
21840  unsigned char iv_str[128];
21841  unsigned char add_str[128];
21842  unsigned char tag_str[128];
21843  unsigned char output[128];
21844  gcm_context ctx;
21845  unsigned int key_len;
21846  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
21847  int ret;
21848 
21849  memset(key_str, 0x00, 128);
21850  memset(src_str, 0x00, 128);
21851  memset(dst_str, 0x00, 257);
21852  memset(iv_str, 0x00, 128);
21853  memset(add_str, 0x00, 128);
21854  memset(tag_str, 0x00, 128);
21855  memset(output, 0x00, 128);
21856 
21857  key_len = unhexify( key_str, "cbeefb3817cb02d617f385cf2371d52c8bcbc29e5e7a55cd2da131ca184c6e89" );
21858  pt_len = unhexify( src_str, "" );
21859  iv_len = unhexify( iv_str, "f74156d6400ae46b612531848bffe18f" );
21860  add_len = unhexify( add_str, "1abe2ab05ceccf2391273126fe4a4426b94d2c3b97a7f1cd2ee6bb952bf4a546e972b5a1701d5ddb0e5bb7a248fcb47107a9fc77e4b9806b68a11850119aa239fa8be1370e3a2e1a8b168f7323afdfc4b8917d92570167848a56132d68876abc386c258a9233dc8a9eb73443b052e842c3d63e8b5369acdd038404e4e9a4b038" );
21861  unhexify( tag_str, "0cb67cec1820339fa0552702dd" );
21862 
21863  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21864  if( 0 == 0 )
21865  {
21866  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21867 
21868  if( strcmp( "FAIL", "FAIL" ) == 0 )
21869  {
21870  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21871  }
21872  else
21873  {
21874  hexify( dst_str, output, pt_len );
21875 
21876  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21877  }
21878  }
21879  }
21880  FCT_TEST_END();
21881 
21882 
21883  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024104_1)
21884  {
21885  unsigned char key_str[128];
21886  unsigned char src_str[128];
21887  unsigned char dst_str[257];
21888  unsigned char iv_str[128];
21889  unsigned char add_str[128];
21890  unsigned char tag_str[128];
21891  unsigned char output[128];
21892  gcm_context ctx;
21893  unsigned int key_len;
21894  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
21895  int ret;
21896 
21897  memset(key_str, 0x00, 128);
21898  memset(src_str, 0x00, 128);
21899  memset(dst_str, 0x00, 257);
21900  memset(iv_str, 0x00, 128);
21901  memset(add_str, 0x00, 128);
21902  memset(tag_str, 0x00, 128);
21903  memset(output, 0x00, 128);
21904 
21905  key_len = unhexify( key_str, "e6f5f65ce2fc8ec3f602f5df90eb7d506dd771337913680ac16bdcd15c56583d" );
21906  pt_len = unhexify( src_str, "" );
21907  iv_len = unhexify( iv_str, "9212a548c597677d1747e98ce6fb18a4" );
21908  add_len = unhexify( add_str, "55ca486c0183d0134925880d2e21dde0af51c4c77c6038a5a9c0497884e0aa4715bdb5b4bb864acc708ac00b511a24fa08496df6a0ca83259110e97a011b876e748a1d0eae2951ce7c22661a3e2ecf50633c50e3d26fa33c2319c139b288825b7aa5efbd133a5ce7483feecb11167099565e3131d5f0cb360f2174f46cb6b37c" );
21909  unhexify( tag_str, "08d7cc52d1637db2a43c399310" );
21910 
21911  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21912  if( 0 == 0 )
21913  {
21914  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21915 
21916  if( strcmp( "FAIL", "" ) == 0 )
21917  {
21918  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21919  }
21920  else
21921  {
21922  hexify( dst_str, output, pt_len );
21923 
21924  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
21925  }
21926  }
21927  }
21928  FCT_TEST_END();
21929 
21930 
21931  FCT_TEST_BGN(gcm_nist_validation_aes_25612801024104_2)
21932  {
21933  unsigned char key_str[128];
21934  unsigned char src_str[128];
21935  unsigned char dst_str[257];
21936  unsigned char iv_str[128];
21937  unsigned char add_str[128];
21938  unsigned char tag_str[128];
21939  unsigned char output[128];
21940  gcm_context ctx;
21941  unsigned int key_len;
21942  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
21943  int ret;
21944 
21945  memset(key_str, 0x00, 128);
21946  memset(src_str, 0x00, 128);
21947  memset(dst_str, 0x00, 257);
21948  memset(iv_str, 0x00, 128);
21949  memset(add_str, 0x00, 128);
21950  memset(tag_str, 0x00, 128);
21951  memset(output, 0x00, 128);
21952 
21953  key_len = unhexify( key_str, "0e9a0391435acb57eae2e6217e0941c79a3ff938ec6a19b8a7db2ea972e49f54" );
21954  pt_len = unhexify( src_str, "" );
21955  iv_len = unhexify( iv_str, "27cd1d7af7e491e30c8110cc01392529" );
21956  add_len = unhexify( add_str, "79140d32bb32dace0779e2d37a0f744d6d973e99a279962b43a6c0af63772e8a0a21d5d9dd3c33d4b218cb2f6f24dd8d93bb4e1e6a788cb93135321ecfed455e747fa919b85b63b9e98b4980a8ccb3b19d50d735742cb5853720c2ad37fa5b0e655149583585830f8d799c0d2e67c0dc24fc9273d9730f3bb367c487a5f89a25" );
21957  unhexify( tag_str, "fbb477dd4b9898a9abc5a45c63" );
21958 
21959  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
21960  if( 0 == 0 )
21961  {
21962  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
21963 
21964  if( strcmp( "FAIL", "FAIL" ) == 0 )
21965  {
21966  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
21967  }
21968  else
21969  {
21970  hexify( dst_str, output, pt_len );
21971 
21972  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
21973  }
21974  }
21975  }
21976  FCT_TEST_END();
21977 
21978 
21979  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102496_0)
21980  {
21981  unsigned char key_str[128];
21982  unsigned char src_str[128];
21983  unsigned char dst_str[257];
21984  unsigned char iv_str[128];
21985  unsigned char add_str[128];
21986  unsigned char tag_str[128];
21987  unsigned char output[128];
21988  gcm_context ctx;
21989  unsigned int key_len;
21990  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
21991  int ret;
21992 
21993  memset(key_str, 0x00, 128);
21994  memset(src_str, 0x00, 128);
21995  memset(dst_str, 0x00, 257);
21996  memset(iv_str, 0x00, 128);
21997  memset(add_str, 0x00, 128);
21998  memset(tag_str, 0x00, 128);
21999  memset(output, 0x00, 128);
22000 
22001  key_len = unhexify( key_str, "55a12eeca637654252e3e40b371667e3f308b00f2fd2af696223e4cd89e3fd4e" );
22002  pt_len = unhexify( src_str, "" );
22003  iv_len = unhexify( iv_str, "8a3793b6441258360f7f4801b03d0b26" );
22004  add_len = unhexify( add_str, "f5810dc5f25e49bd6d94bc63c2494aa7a579a4056a25f1dd9b2734d0b8731ee52523edd54ff475651d45c213e1bf254327fb0e2c41a7d85345b02bcc9d27b08915d332e1659671991a4bb74055967bebbba6ecceb182f57977130623d5a7b2175fa5a84b334868661c1f450b95562928b4791759796a177d59ed18bbf141e2ad" );
22005  unhexify( tag_str, "99230019630647aedebbb24b" );
22006 
22007  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22008  if( 0 == 0 )
22009  {
22010  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22011 
22012  if( strcmp( "FAIL", "FAIL" ) == 0 )
22013  {
22014  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22015  }
22016  else
22017  {
22018  hexify( dst_str, output, pt_len );
22019 
22020  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
22021  }
22022  }
22023  }
22024  FCT_TEST_END();
22025 
22026 
22027  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102496_1)
22028  {
22029  unsigned char key_str[128];
22030  unsigned char src_str[128];
22031  unsigned char dst_str[257];
22032  unsigned char iv_str[128];
22033  unsigned char add_str[128];
22034  unsigned char tag_str[128];
22035  unsigned char output[128];
22036  gcm_context ctx;
22037  unsigned int key_len;
22038  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
22039  int ret;
22040 
22041  memset(key_str, 0x00, 128);
22042  memset(src_str, 0x00, 128);
22043  memset(dst_str, 0x00, 257);
22044  memset(iv_str, 0x00, 128);
22045  memset(add_str, 0x00, 128);
22046  memset(tag_str, 0x00, 128);
22047  memset(output, 0x00, 128);
22048 
22049  key_len = unhexify( key_str, "3d353f870a9c088de5674efd97646b9c5420b2bcdfcffefcadd81682847e5331" );
22050  pt_len = unhexify( src_str, "" );
22051  iv_len = unhexify( iv_str, "f267fa982af5c85359b6447f9b7715ea" );
22052  add_len = unhexify( add_str, "7cf55630867af5dff747c8dd25bcc531d94a7730a20b6c03d46059ea93fcaa00d07ee17dad0e0dff814b02dfef0cbe00b37fd2f5f95ead7c72be60016f2934d7683fc1e47185c7211c49cb03e209b088edb14e533dbcb792ab7033728904f7ff12381a236dba97894ec1fafcf853ab15fff343f9265d0283acef10168ffd1271" );
22053  unhexify( tag_str, "9553b583d4f9a1a8946fe053" );
22054 
22055  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22056  if( 0 == 0 )
22057  {
22058  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22059 
22060  if( strcmp( "FAIL", "FAIL" ) == 0 )
22061  {
22062  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22063  }
22064  else
22065  {
22066  hexify( dst_str, output, pt_len );
22067 
22068  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
22069  }
22070  }
22071  }
22072  FCT_TEST_END();
22073 
22074 
22075  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102496_2)
22076  {
22077  unsigned char key_str[128];
22078  unsigned char src_str[128];
22079  unsigned char dst_str[257];
22080  unsigned char iv_str[128];
22081  unsigned char add_str[128];
22082  unsigned char tag_str[128];
22083  unsigned char output[128];
22084  gcm_context ctx;
22085  unsigned int key_len;
22086  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
22087  int ret;
22088 
22089  memset(key_str, 0x00, 128);
22090  memset(src_str, 0x00, 128);
22091  memset(dst_str, 0x00, 257);
22092  memset(iv_str, 0x00, 128);
22093  memset(add_str, 0x00, 128);
22094  memset(tag_str, 0x00, 128);
22095  memset(output, 0x00, 128);
22096 
22097  key_len = unhexify( key_str, "d227c9ff5d17a984983056fb96f3991932ae8132377529c29238cf7db94a359d" );
22098  pt_len = unhexify( src_str, "" );
22099  iv_len = unhexify( iv_str, "b8f6536f376a7efe0e684acf350bae70" );
22100  add_len = unhexify( add_str, "1cc25da31f90de7fa47ebce92754d3faa99f88d4e25ccab45645c1acdf850d55d7f02f61a0bfdc3125f29259d7da8abef532fe0966c63d3486753c8a2cb63a39349a0641b2f2b9526a03b97d58ca60fbb054c6c164ff2836688b0cad54df2b165bc082eeae660e768dde5130e30f8edc863446661c74da69b9e56de8ae388da0" );
22101  unhexify( tag_str, "44b95a37fab232c2efb11231" );
22102 
22103  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22104  if( 0 == 0 )
22105  {
22106  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22107 
22108  if( strcmp( "FAIL", "" ) == 0 )
22109  {
22110  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22111  }
22112  else
22113  {
22114  hexify( dst_str, output, pt_len );
22115 
22116  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
22117  }
22118  }
22119  }
22120  FCT_TEST_END();
22121 
22122 
22123  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102464_0)
22124  {
22125  unsigned char key_str[128];
22126  unsigned char src_str[128];
22127  unsigned char dst_str[257];
22128  unsigned char iv_str[128];
22129  unsigned char add_str[128];
22130  unsigned char tag_str[128];
22131  unsigned char output[128];
22132  gcm_context ctx;
22133  unsigned int key_len;
22134  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
22135  int ret;
22136 
22137  memset(key_str, 0x00, 128);
22138  memset(src_str, 0x00, 128);
22139  memset(dst_str, 0x00, 257);
22140  memset(iv_str, 0x00, 128);
22141  memset(add_str, 0x00, 128);
22142  memset(tag_str, 0x00, 128);
22143  memset(output, 0x00, 128);
22144 
22145  key_len = unhexify( key_str, "b2a57ef85ffcf0548c3d087012b336c46f6574cf1d97ca087bfad042ee83eec2" );
22146  pt_len = unhexify( src_str, "" );
22147  iv_len = unhexify( iv_str, "3d580402d2a8dc4d7466e5dcb456be7a" );
22148  add_len = unhexify( add_str, "c2b9e95c16e55028794a63ef82d11fb83a2a75dc34a81f238e472c33264534bdd54cd07d02a0ecf9019ad1a6d6c779f339dd479e37940486950f183bade24fca2f24f06d4037b3555b09fc80279ea311769473eb0630b694a29823324cdf780d7d1a50d89f7a23b05f7a8c3ad04b7949aa9e6a55978ba48d8078b5a2fd3c1bbb" );
22149  unhexify( tag_str, "072d4118e70cd5ab" );
22150 
22151  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22152  if( 0 == 0 )
22153  {
22154  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22155 
22156  if( strcmp( "FAIL", "" ) == 0 )
22157  {
22158  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22159  }
22160  else
22161  {
22162  hexify( dst_str, output, pt_len );
22163 
22164  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
22165  }
22166  }
22167  }
22168  FCT_TEST_END();
22169 
22170 
22171  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102464_1)
22172  {
22173  unsigned char key_str[128];
22174  unsigned char src_str[128];
22175  unsigned char dst_str[257];
22176  unsigned char iv_str[128];
22177  unsigned char add_str[128];
22178  unsigned char tag_str[128];
22179  unsigned char output[128];
22180  gcm_context ctx;
22181  unsigned int key_len;
22182  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
22183  int ret;
22184 
22185  memset(key_str, 0x00, 128);
22186  memset(src_str, 0x00, 128);
22187  memset(dst_str, 0x00, 257);
22188  memset(iv_str, 0x00, 128);
22189  memset(add_str, 0x00, 128);
22190  memset(tag_str, 0x00, 128);
22191  memset(output, 0x00, 128);
22192 
22193  key_len = unhexify( key_str, "63889ed5bf2c27d518a696b71c0f85592e3337aae95b5bf07289e4c5dfdc088d" );
22194  pt_len = unhexify( src_str, "" );
22195  iv_len = unhexify( iv_str, "1ad534280a0fac7dce31f2ae4fb73f5a" );
22196  add_len = unhexify( add_str, "be1b9dabea33bb9443e27f674b27931c0fba699a33dc86fab29e50b76a9441030444b465317bbf2949faf908bc1b501d11a5ea2042e4b460a85f3be5836729e523d99b56ef39231d5c6d8ae2c2ab36ef44e2aa02a1f2c559c6e333216c7f9ed5f9b880a88e920219204c99a3ae8f90afd1396563bc59a691a93e0070b0b5fd90" );
22197  unhexify( tag_str, "1bcea0ac2c1a0c73" );
22198 
22199  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22200  if( 0 == 0 )
22201  {
22202  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22203 
22204  if( strcmp( "FAIL", "" ) == 0 )
22205  {
22206  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22207  }
22208  else
22209  {
22210  hexify( dst_str, output, pt_len );
22211 
22212  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
22213  }
22214  }
22215  }
22216  FCT_TEST_END();
22217 
22218 
22219  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102464_2)
22220  {
22221  unsigned char key_str[128];
22222  unsigned char src_str[128];
22223  unsigned char dst_str[257];
22224  unsigned char iv_str[128];
22225  unsigned char add_str[128];
22226  unsigned char tag_str[128];
22227  unsigned char output[128];
22228  gcm_context ctx;
22229  unsigned int key_len;
22230  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
22231  int ret;
22232 
22233  memset(key_str, 0x00, 128);
22234  memset(src_str, 0x00, 128);
22235  memset(dst_str, 0x00, 257);
22236  memset(iv_str, 0x00, 128);
22237  memset(add_str, 0x00, 128);
22238  memset(tag_str, 0x00, 128);
22239  memset(output, 0x00, 128);
22240 
22241  key_len = unhexify( key_str, "94e3e2c17cfb6f52d4fdba3ba6d18bba891b6662e85df14d7e61f04adb69e0e5" );
22242  pt_len = unhexify( src_str, "" );
22243  iv_len = unhexify( iv_str, "8a80efb3bfe220526997543409fddb4d" );
22244  add_len = unhexify( add_str, "05da1b0f7ac6eef488d3f087ecae7f35abe3ef36d339709dc3fcb5b471979268ee894c3b6c7f984300d70bc5ea5fba923bfb41d88652bdaecc710964c51f3e2ae2c280b7d6c8e3b9a8a8991d19d92d46c8a158123187f19397ad1ad9080b4ffd04b82b5d68d89dacd3e76439013728c1395263e722b28e45dabf1ef46b8e70b5" );
22245  unhexify( tag_str, "faa5c13d899f17ea" );
22246 
22247  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22248  if( 0 == 0 )
22249  {
22250  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22251 
22252  if( strcmp( "FAIL", "" ) == 0 )
22253  {
22254  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22255  }
22256  else
22257  {
22258  hexify( dst_str, output, pt_len );
22259 
22260  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
22261  }
22262  }
22263  }
22264  FCT_TEST_END();
22265 
22266 
22267  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102432_0)
22268  {
22269  unsigned char key_str[128];
22270  unsigned char src_str[128];
22271  unsigned char dst_str[257];
22272  unsigned char iv_str[128];
22273  unsigned char add_str[128];
22274  unsigned char tag_str[128];
22275  unsigned char output[128];
22276  gcm_context ctx;
22277  unsigned int key_len;
22278  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
22279  int ret;
22280 
22281  memset(key_str, 0x00, 128);
22282  memset(src_str, 0x00, 128);
22283  memset(dst_str, 0x00, 257);
22284  memset(iv_str, 0x00, 128);
22285  memset(add_str, 0x00, 128);
22286  memset(tag_str, 0x00, 128);
22287  memset(output, 0x00, 128);
22288 
22289  key_len = unhexify( key_str, "fe5e479ad0d79dbf717a1f51f5250d467819e444b79cb3def1e0033c80ddadd8" );
22290  pt_len = unhexify( src_str, "" );
22291  iv_len = unhexify( iv_str, "47ce838083fd070d8544c0ad5337cdc6" );
22292  add_len = unhexify( add_str, "98476bf05a18c4ff1b6024dd779c1ac06d838705a0a83fe42bee5fc6ebf3b2a1a5049b67f4aabc8239cd6ff56504bcbad1e2498c159bbec2a6635933945f6ea49e5bc763dcf94f4b3643d3888f16105abb0965e24f51cb4949406124145e9ae31cc76535b4178492f38b311099df2751f674363ae7a58f6f93019653b7e6a6f0" );
22293  unhexify( tag_str, "a3958500" );
22294 
22295  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22296  if( 0 == 0 )
22297  {
22298  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22299 
22300  if( strcmp( "FAIL", "" ) == 0 )
22301  {
22302  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22303  }
22304  else
22305  {
22306  hexify( dst_str, output, pt_len );
22307 
22308  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
22309  }
22310  }
22311  }
22312  FCT_TEST_END();
22313 
22314 
22315  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102432_1)
22316  {
22317  unsigned char key_str[128];
22318  unsigned char src_str[128];
22319  unsigned char dst_str[257];
22320  unsigned char iv_str[128];
22321  unsigned char add_str[128];
22322  unsigned char tag_str[128];
22323  unsigned char output[128];
22324  gcm_context ctx;
22325  unsigned int key_len;
22326  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
22327  int ret;
22328 
22329  memset(key_str, 0x00, 128);
22330  memset(src_str, 0x00, 128);
22331  memset(dst_str, 0x00, 257);
22332  memset(iv_str, 0x00, 128);
22333  memset(add_str, 0x00, 128);
22334  memset(tag_str, 0x00, 128);
22335  memset(output, 0x00, 128);
22336 
22337  key_len = unhexify( key_str, "27d4dedb71a8f68ca5ce2b9e56da772bf5a09b7981d41cd29f485bd2d1adb8d4" );
22338  pt_len = unhexify( src_str, "" );
22339  iv_len = unhexify( iv_str, "7e6f0343c54539717a97b6c8b9f7dec4" );
22340  add_len = unhexify( add_str, "d386db78043f719b7e137cbf79a7f53dda2fe3baccbebb57d499f6eb168e5151f10081d76b72ae0f30165efbdda469e826f9246e59dbcad5c0b27691c00d6c192c24073e99c19cf8c142087c0b83c4ce2fc7ba1e696394e5620ab2d117d5dcd2ac2298997407fd5de07d008de8f9941a4a5f8074736a59404118afac0700be6c" );
22341  unhexify( tag_str, "50fd1798" );
22342 
22343  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22344  if( 0 == 0 )
22345  {
22346  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22347 
22348  if( strcmp( "FAIL", "" ) == 0 )
22349  {
22350  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22351  }
22352  else
22353  {
22354  hexify( dst_str, output, pt_len );
22355 
22356  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
22357  }
22358  }
22359  }
22360  FCT_TEST_END();
22361 
22362 
22363  FCT_TEST_BGN(gcm_nist_validation_aes_2561280102432_2)
22364  {
22365  unsigned char key_str[128];
22366  unsigned char src_str[128];
22367  unsigned char dst_str[257];
22368  unsigned char iv_str[128];
22369  unsigned char add_str[128];
22370  unsigned char tag_str[128];
22371  unsigned char output[128];
22372  gcm_context ctx;
22373  unsigned int key_len;
22374  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
22375  int ret;
22376 
22377  memset(key_str, 0x00, 128);
22378  memset(src_str, 0x00, 128);
22379  memset(dst_str, 0x00, 257);
22380  memset(iv_str, 0x00, 128);
22381  memset(add_str, 0x00, 128);
22382  memset(tag_str, 0x00, 128);
22383  memset(output, 0x00, 128);
22384 
22385  key_len = unhexify( key_str, "5a7aa836a469d28542d0d24d3232fad266da8fc889c6b6038b726d3da25f7b20" );
22386  pt_len = unhexify( src_str, "" );
22387  iv_len = unhexify( iv_str, "9faf7cd805803e143ec8f3f13475efd2" );
22388  add_len = unhexify( add_str, "1006c707f608728b2bf64734062b12a5625062bcdcb80a3ce2058352a2922d5e6fbe19681b4f0d79ad3c837f81e72f2fbf8df669894e802a39072b26c286f4b05188c708f7c6edd5f5bb90b87ffa95b86d84d6c1c4591b11d22c772a8ad7f2fe6bd8b46be0e93672df2e8bff8ba80629e1846cfd4603e75f2d98874665c1a089" );
22389  unhexify( tag_str, "07764143" );
22390 
22391  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22392  if( 0 == 0 )
22393  {
22394  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22395 
22396  if( strcmp( "FAIL", "" ) == 0 )
22397  {
22398  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22399  }
22400  else
22401  {
22402  hexify( dst_str, output, pt_len );
22403 
22404  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
22405  }
22406  }
22407  }
22408  FCT_TEST_END();
22409 
22410 
22411  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240128_0)
22412  {
22413  unsigned char key_str[128];
22414  unsigned char src_str[128];
22415  unsigned char dst_str[257];
22416  unsigned char iv_str[128];
22417  unsigned char add_str[128];
22418  unsigned char tag_str[128];
22419  unsigned char output[128];
22420  gcm_context ctx;
22421  unsigned int key_len;
22422  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
22423  int ret;
22424 
22425  memset(key_str, 0x00, 128);
22426  memset(src_str, 0x00, 128);
22427  memset(dst_str, 0x00, 257);
22428  memset(iv_str, 0x00, 128);
22429  memset(add_str, 0x00, 128);
22430  memset(tag_str, 0x00, 128);
22431  memset(output, 0x00, 128);
22432 
22433  key_len = unhexify( key_str, "a9444fd176acbe061d0221fde3ddfcc4ff74e995d981a831297c4cbda51c22a1" );
22434  pt_len = unhexify( src_str, "c146ff5a988496cad7eced7a2ea471e0117d5d6bd2562c23ce9db4bf36d83ba3fc22e90486ec288a627d208e0b2fd3b65f8301cf7fc41d97959981a95cd1cf37effc46db99b94b21c941c3613c26a10b1a6b7793f467d58ff5134612230f1c49d7e1fcf664fe52fc6eca46273982f6fe729b009d90eb8d8e4a0b0dbe907b76da" );
22435  iv_len = unhexify( iv_str, "5714732145470da1c42452e10cd274b5" );
22436  add_len = unhexify( add_str, "" );
22437  unhexify( tag_str, "db85b830a03357f408587410ebafd10d" );
22438 
22439  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22440  if( 0 == 0 )
22441  {
22442  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22443 
22444  if( strcmp( "FAIL", "a3cad9a57fa28e6f6aaa37150a803bf8b77e765f0702e492c4e5ebb31ae6b12d791149153e469a92bb625784a699fd7ca517500ee3f2851840ba67063b28b481e24ba441314e8b7128f5aaccaf4c4e2c92258eb27310bf031422b7fc2f220f621d4c64837c9377222aced2411628018a409a744902c9e95c14b77d5bb7f5846b" ) == 0 )
22445  {
22446  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22447  }
22448  else
22449  {
22450  hexify( dst_str, output, pt_len );
22451 
22452  fct_chk( strcmp( (char *) dst_str, "a3cad9a57fa28e6f6aaa37150a803bf8b77e765f0702e492c4e5ebb31ae6b12d791149153e469a92bb625784a699fd7ca517500ee3f2851840ba67063b28b481e24ba441314e8b7128f5aaccaf4c4e2c92258eb27310bf031422b7fc2f220f621d4c64837c9377222aced2411628018a409a744902c9e95c14b77d5bb7f5846b" ) == 0 );
22453  }
22454  }
22455  }
22456  FCT_TEST_END();
22457 
22458 
22459  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240128_1)
22460  {
22461  unsigned char key_str[128];
22462  unsigned char src_str[128];
22463  unsigned char dst_str[257];
22464  unsigned char iv_str[128];
22465  unsigned char add_str[128];
22466  unsigned char tag_str[128];
22467  unsigned char output[128];
22468  gcm_context ctx;
22469  unsigned int key_len;
22470  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
22471  int ret;
22472 
22473  memset(key_str, 0x00, 128);
22474  memset(src_str, 0x00, 128);
22475  memset(dst_str, 0x00, 257);
22476  memset(iv_str, 0x00, 128);
22477  memset(add_str, 0x00, 128);
22478  memset(tag_str, 0x00, 128);
22479  memset(output, 0x00, 128);
22480 
22481  key_len = unhexify( key_str, "686d3bd071e3f46f180611bc4ec8d7726fe72b6c617e7d42b3339f53918c9e36" );
22482  pt_len = unhexify( src_str, "21983ad66449c557263aef299da6eef8f31d576fc17ed2dac3e836f7c2ceaff3094b2695452680e188df10c174810efd1fbaa6c832baedce0b92e4c7121447f6461ac909b4302cdf658095b1de532b536faa4fb38cfdf4192eb5c3fe090d979a343492f841b1edc6eb24b24bdcb90bbbe36d5f8409ce7d27194a7bb995ecc387" );
22483  iv_len = unhexify( iv_str, "a714e51e43aecfe2fda8f824ea1dc4b7" );
22484  add_len = unhexify( add_str, "" );
22485  unhexify( tag_str, "cd30c3618c10d57e9a4477b4a44c5c36" );
22486 
22487  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22488  if( 0 == 0 )
22489  {
22490  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22491 
22492  if( strcmp( "FAIL", "9610908a0eb2ee885981c9e512e1a55075a212d311073bbb2fb9248cce07af16ee4c58bdc8dbe806d28480f9065838146f3e1eb3ae97012cfe53863a13d487f061a49a6c78ca22a321fa25157dbe68c47d78f2359540cc9031ee42d78855ed90e6b8ea3d67725bfffcb6db3d438c982b5f88d9b660f7d82cb300c1fa1edebb6b" ) == 0 )
22493  {
22494  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22495  }
22496  else
22497  {
22498  hexify( dst_str, output, pt_len );
22499 
22500  fct_chk( strcmp( (char *) dst_str, "9610908a0eb2ee885981c9e512e1a55075a212d311073bbb2fb9248cce07af16ee4c58bdc8dbe806d28480f9065838146f3e1eb3ae97012cfe53863a13d487f061a49a6c78ca22a321fa25157dbe68c47d78f2359540cc9031ee42d78855ed90e6b8ea3d67725bfffcb6db3d438c982b5f88d9b660f7d82cb300c1fa1edebb6b" ) == 0 );
22501  }
22502  }
22503  }
22504  FCT_TEST_END();
22505 
22506 
22507  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240128_2)
22508  {
22509  unsigned char key_str[128];
22510  unsigned char src_str[128];
22511  unsigned char dst_str[257];
22512  unsigned char iv_str[128];
22513  unsigned char add_str[128];
22514  unsigned char tag_str[128];
22515  unsigned char output[128];
22516  gcm_context ctx;
22517  unsigned int key_len;
22518  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
22519  int ret;
22520 
22521  memset(key_str, 0x00, 128);
22522  memset(src_str, 0x00, 128);
22523  memset(dst_str, 0x00, 257);
22524  memset(iv_str, 0x00, 128);
22525  memset(add_str, 0x00, 128);
22526  memset(tag_str, 0x00, 128);
22527  memset(output, 0x00, 128);
22528 
22529  key_len = unhexify( key_str, "6fe81f15a02e2ecf46e61199c057102d160e6b5d447d4a275972323fff908c3e" );
22530  pt_len = unhexify( src_str, "0b4ee0385e6665da8fd2ae47f2d0cf1c5bd395a3bb447047ab5a3ae0b95355bf83d0381119a8d4c01acbe60cd7885da650502f73498a682fdc94f7b14f4c753226064fa15e3a90a6083e053f52f404b0d22394e243b187f913ee2c6bb16c3033f79d794852071970523a67467ce63c35390c163775de2be68b505a63f60245e8" );
22531  iv_len = unhexify( iv_str, "91d55cfdcdcd7d735d48100ff82227c3" );
22532  add_len = unhexify( add_str, "" );
22533  unhexify( tag_str, "cd7da82e890b6d7480c7186b2ea7e6f1" );
22534 
22535  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22536  if( 0 == 0 )
22537  {
22538  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22539 
22540  if( strcmp( "FAIL", "FAIL" ) == 0 )
22541  {
22542  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22543  }
22544  else
22545  {
22546  hexify( dst_str, output, pt_len );
22547 
22548  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
22549  }
22550  }
22551  }
22552  FCT_TEST_END();
22553 
22554 
22555  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240120_0)
22556  {
22557  unsigned char key_str[128];
22558  unsigned char src_str[128];
22559  unsigned char dst_str[257];
22560  unsigned char iv_str[128];
22561  unsigned char add_str[128];
22562  unsigned char tag_str[128];
22563  unsigned char output[128];
22564  gcm_context ctx;
22565  unsigned int key_len;
22566  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
22567  int ret;
22568 
22569  memset(key_str, 0x00, 128);
22570  memset(src_str, 0x00, 128);
22571  memset(dst_str, 0x00, 257);
22572  memset(iv_str, 0x00, 128);
22573  memset(add_str, 0x00, 128);
22574  memset(tag_str, 0x00, 128);
22575  memset(output, 0x00, 128);
22576 
22577  key_len = unhexify( key_str, "4c2095e1379389dc3810e8819314f5a2f87d1494213c5b1de1a402f7f4f746c4" );
22578  pt_len = unhexify( src_str, "26ec8ebac0560538a948afbc18fb730e9a91f21392bde24b88b200f96114b229a5b57fa9d02cf10e6592d4dfb28bf0f00740c61157ce28784e9066ea3afd44ecf3a494723610cb593c0feffc6897e3435c6f448697ad3e241685c4e133eff53bdd0fe44dd8a033cfb1e1ea37a493934eb5303ae6ef47ce6478f767ef9e3301ab" );
22579  iv_len = unhexify( iv_str, "19788b2e0bd757947596676436e22df1" );
22580  add_len = unhexify( add_str, "" );
22581  unhexify( tag_str, "f26a20bea561004267a0bfbf01674e" );
22582 
22583  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22584  if( 0 == 0 )
22585  {
22586  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22587 
22588  if( strcmp( "FAIL", "FAIL" ) == 0 )
22589  {
22590  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22591  }
22592  else
22593  {
22594  hexify( dst_str, output, pt_len );
22595 
22596  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
22597  }
22598  }
22599  }
22600  FCT_TEST_END();
22601 
22602 
22603  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240120_1)
22604  {
22605  unsigned char key_str[128];
22606  unsigned char src_str[128];
22607  unsigned char dst_str[257];
22608  unsigned char iv_str[128];
22609  unsigned char add_str[128];
22610  unsigned char tag_str[128];
22611  unsigned char output[128];
22612  gcm_context ctx;
22613  unsigned int key_len;
22614  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
22615  int ret;
22616 
22617  memset(key_str, 0x00, 128);
22618  memset(src_str, 0x00, 128);
22619  memset(dst_str, 0x00, 257);
22620  memset(iv_str, 0x00, 128);
22621  memset(add_str, 0x00, 128);
22622  memset(tag_str, 0x00, 128);
22623  memset(output, 0x00, 128);
22624 
22625  key_len = unhexify( key_str, "be5351efc0277afc9759ec2464a22cb4401f7a17efd1a205e7af023c7ed30ee1" );
22626  pt_len = unhexify( src_str, "1eca91406f338fc09c2988b1d7dc8c409d719300c03840a497d7b680cdd5e09b144903477f7116a934e1d931cf368af1fc2a0a0e7caa95475a3cd7bf585a16fda31eb3f8201db0216b37a1635c1c030836b3dd05ca5b0194388fa198e717822131d5d4318690ef82d35ac80b27fff19aec8f020dc6c6ce28f0813bbbf8230ad9" );
22627  iv_len = unhexify( iv_str, "c6b26117d9dbd80c1c242ad41abe2acc" );
22628  add_len = unhexify( add_str, "" );
22629  unhexify( tag_str, "61051d6c0801b4a6b6ca0124c019f3" );
22630 
22631  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22632  if( 0 == 0 )
22633  {
22634  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22635 
22636  if( strcmp( "FAIL", "95447aded336d6c20d483a6f062d533efed0261ad321d37bf8b7321b98f55c0f0082ce7f3d341b18fea29a72fc909d30cd8c84a1640227227287674a9b2f16a81b191ecf3b6232d656c32d7b38bea82a1b27d5897694a2be56d7e39aa1e725f326b91bad20455f58a94a545170cb43d13d4b91e1cee82abb6a6e0d95d4de0567" ) == 0 )
22637  {
22638  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22639  }
22640  else
22641  {
22642  hexify( dst_str, output, pt_len );
22643 
22644  fct_chk( strcmp( (char *) dst_str, "95447aded336d6c20d483a6f062d533efed0261ad321d37bf8b7321b98f55c0f0082ce7f3d341b18fea29a72fc909d30cd8c84a1640227227287674a9b2f16a81b191ecf3b6232d656c32d7b38bea82a1b27d5897694a2be56d7e39aa1e725f326b91bad20455f58a94a545170cb43d13d4b91e1cee82abb6a6e0d95d4de0567" ) == 0 );
22645  }
22646  }
22647  }
22648  FCT_TEST_END();
22649 
22650 
22651  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240120_2)
22652  {
22653  unsigned char key_str[128];
22654  unsigned char src_str[128];
22655  unsigned char dst_str[257];
22656  unsigned char iv_str[128];
22657  unsigned char add_str[128];
22658  unsigned char tag_str[128];
22659  unsigned char output[128];
22660  gcm_context ctx;
22661  unsigned int key_len;
22662  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
22663  int ret;
22664 
22665  memset(key_str, 0x00, 128);
22666  memset(src_str, 0x00, 128);
22667  memset(dst_str, 0x00, 257);
22668  memset(iv_str, 0x00, 128);
22669  memset(add_str, 0x00, 128);
22670  memset(tag_str, 0x00, 128);
22671  memset(output, 0x00, 128);
22672 
22673  key_len = unhexify( key_str, "814c2cdfdeecf39d43bb141fbfc62dac44f7552c5e5dac2d4913303fc860119b" );
22674  pt_len = unhexify( src_str, "0d3013a1d7132f685d001420daa6c7b643bc36b887511acc4588237d3b412c79e4ebba29c08248ad46c7239e8daa232b7483c9c4e3d1c0bbebc696401efe21f7fd6fc0525a4ab81bd9a893d5f7ab23b70ed07c00f33649b8a996a006de6c94f7793f72848793f4d5b31311c68aae1e715b37409fbe506dac038a0950f05fe82b" );
22675  iv_len = unhexify( iv_str, "0db3ade15cb0dea98a47d1377e034d63" );
22676  add_len = unhexify( add_str, "" );
22677  unhexify( tag_str, "e62f910b6046ba4e934d3cfc6e024c" );
22678 
22679  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22680  if( 0 == 0 )
22681  {
22682  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22683 
22684  if( strcmp( "FAIL", "374d03cfe4dacf668df5e703902cc784f011f418b43887702972dcc3f021bcb9bdd61ed5425f2975b6da7052c4859501eb2f295eb95d10ba6b2d74e7decc1acacebf8568e93a70a7f40be41ac38db6f751518c2f44a69c01c44745c51ad9a333eda9c89d001aa644f1e4063a8eb2a3592e21c6abc515b5aacaec8c32bcf1d3c4" ) == 0 )
22685  {
22686  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22687  }
22688  else
22689  {
22690  hexify( dst_str, output, pt_len );
22691 
22692  fct_chk( strcmp( (char *) dst_str, "374d03cfe4dacf668df5e703902cc784f011f418b43887702972dcc3f021bcb9bdd61ed5425f2975b6da7052c4859501eb2f295eb95d10ba6b2d74e7decc1acacebf8568e93a70a7f40be41ac38db6f751518c2f44a69c01c44745c51ad9a333eda9c89d001aa644f1e4063a8eb2a3592e21c6abc515b5aacaec8c32bcf1d3c4" ) == 0 );
22693  }
22694  }
22695  }
22696  FCT_TEST_END();
22697 
22698 
22699  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240112_0)
22700  {
22701  unsigned char key_str[128];
22702  unsigned char src_str[128];
22703  unsigned char dst_str[257];
22704  unsigned char iv_str[128];
22705  unsigned char add_str[128];
22706  unsigned char tag_str[128];
22707  unsigned char output[128];
22708  gcm_context ctx;
22709  unsigned int key_len;
22710  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
22711  int ret;
22712 
22713  memset(key_str, 0x00, 128);
22714  memset(src_str, 0x00, 128);
22715  memset(dst_str, 0x00, 257);
22716  memset(iv_str, 0x00, 128);
22717  memset(add_str, 0x00, 128);
22718  memset(tag_str, 0x00, 128);
22719  memset(output, 0x00, 128);
22720 
22721  key_len = unhexify( key_str, "1ae4541110f2bc4f83cd720b5c40c8315413d896e034b75007f172baa13d29ec" );
22722  pt_len = unhexify( src_str, "5ea811e7fbfc0e00bf2a6abfac50cad9efd90041c5f7fb8f046a0fecbd193b70a2de8a774d01dd3cd54f848cb3e9f5152ee1b052ba698bebfba1fbbdae44a260447d6e6482640ae4d01c9cac3d37d4ffe9a0de0b6001de504a33ef7620efe3ce48ecd6f5b1b3a89185c86d4d662a843ff730e040e3668d6170be4cced8a18a1c" );
22723  iv_len = unhexify( iv_str, "83f98eec51ee4cae4cb7fe28b64d1355" );
22724  add_len = unhexify( add_str, "" );
22725  unhexify( tag_str, "df47eef69ba2faab887aa8f48e4b" );
22726 
22727  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22728  if( 0 == 0 )
22729  {
22730  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22731 
22732  if( strcmp( "FAIL", "FAIL" ) == 0 )
22733  {
22734  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22735  }
22736  else
22737  {
22738  hexify( dst_str, output, pt_len );
22739 
22740  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
22741  }
22742  }
22743  }
22744  FCT_TEST_END();
22745 
22746 
22747  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240112_1)
22748  {
22749  unsigned char key_str[128];
22750  unsigned char src_str[128];
22751  unsigned char dst_str[257];
22752  unsigned char iv_str[128];
22753  unsigned char add_str[128];
22754  unsigned char tag_str[128];
22755  unsigned char output[128];
22756  gcm_context ctx;
22757  unsigned int key_len;
22758  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
22759  int ret;
22760 
22761  memset(key_str, 0x00, 128);
22762  memset(src_str, 0x00, 128);
22763  memset(dst_str, 0x00, 257);
22764  memset(iv_str, 0x00, 128);
22765  memset(add_str, 0x00, 128);
22766  memset(tag_str, 0x00, 128);
22767  memset(output, 0x00, 128);
22768 
22769  key_len = unhexify( key_str, "20c9b662ec4bd13bf58d64cb0a7159b0e7fee4703af66292bf75c8bd6e42e8dc" );
22770  pt_len = unhexify( src_str, "45b64f2ed5ac707890c0c1726adf338770ce6a728fe86bb372c4c49409a32705f881bc4d31a27c455c7c7df9dd2c541743523e7d32f88930d988857847f011be5f5f31a31e8812745147cbff5c1294d0fd4a7285db4833f22bf1975250da99c4d0dd2c9688d7f8001bb6ef2bc898ce4d42c5b78e74645b56ce992338f49d4183" );
22771  iv_len = unhexify( iv_str, "2bc0847d46f3d1064bbf8fe8567f54a2" );
22772  add_len = unhexify( add_str, "" );
22773  unhexify( tag_str, "5a1bf25aa8d5c3fe5cf1be8e54a1" );
22774 
22775  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22776  if( 0 == 0 )
22777  {
22778  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22779 
22780  if( strcmp( "FAIL", "9079d6275db076625e8474c2914fe483d413d5339202f98f06c3b0ef063d8f3d31029deaf7f9349bfec57e5cf11f46f02d5a6520c7992efc951adbbea6d08e53faeb10dfe8b67ee4685da9ea4fe932551a65821147d06d4c462338e6ddda52017c2bc187fd6d02b7d5193f77da809d4e59a9061efad2f9cadbc4cd9b29728d32" ) == 0 )
22781  {
22782  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22783  }
22784  else
22785  {
22786  hexify( dst_str, output, pt_len );
22787 
22788  fct_chk( strcmp( (char *) dst_str, "9079d6275db076625e8474c2914fe483d413d5339202f98f06c3b0ef063d8f3d31029deaf7f9349bfec57e5cf11f46f02d5a6520c7992efc951adbbea6d08e53faeb10dfe8b67ee4685da9ea4fe932551a65821147d06d4c462338e6ddda52017c2bc187fd6d02b7d5193f77da809d4e59a9061efad2f9cadbc4cd9b29728d32" ) == 0 );
22789  }
22790  }
22791  }
22792  FCT_TEST_END();
22793 
22794 
22795  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240112_2)
22796  {
22797  unsigned char key_str[128];
22798  unsigned char src_str[128];
22799  unsigned char dst_str[257];
22800  unsigned char iv_str[128];
22801  unsigned char add_str[128];
22802  unsigned char tag_str[128];
22803  unsigned char output[128];
22804  gcm_context ctx;
22805  unsigned int key_len;
22806  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
22807  int ret;
22808 
22809  memset(key_str, 0x00, 128);
22810  memset(src_str, 0x00, 128);
22811  memset(dst_str, 0x00, 257);
22812  memset(iv_str, 0x00, 128);
22813  memset(add_str, 0x00, 128);
22814  memset(tag_str, 0x00, 128);
22815  memset(output, 0x00, 128);
22816 
22817  key_len = unhexify( key_str, "0a1554db37f2e275732a77e521cbd8170729d8677a85db73feacf3c66a89d689" );
22818  pt_len = unhexify( src_str, "5421d93b7e6e0091978c673df4f3a406aef5f13eb5e6f95da19b0783308cbe26d4fd6c669cc4a9f069d7e62e4c6fad14b80e918fe91556a9a941a28b3dbf776a68ac7c42df7059b5ed713e78120aec84e7b68e96226c2b5e11a994864ed61b122e7e42ef6cfdae278fadbae1b3ea3362f4e6dc68eef6a70477b8a3ffcfba0df9" );
22819  iv_len = unhexify( iv_str, "b9194a4d42b139f04c29178467955f1d" );
22820  add_len = unhexify( add_str, "" );
22821  unhexify( tag_str, "05949d591793ca52e679bfdf64f3" );
22822 
22823  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22824  if( 0 == 0 )
22825  {
22826  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22827 
22828  if( strcmp( "FAIL", "FAIL" ) == 0 )
22829  {
22830  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22831  }
22832  else
22833  {
22834  hexify( dst_str, output, pt_len );
22835 
22836  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
22837  }
22838  }
22839  }
22840  FCT_TEST_END();
22841 
22842 
22843  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240104_0)
22844  {
22845  unsigned char key_str[128];
22846  unsigned char src_str[128];
22847  unsigned char dst_str[257];
22848  unsigned char iv_str[128];
22849  unsigned char add_str[128];
22850  unsigned char tag_str[128];
22851  unsigned char output[128];
22852  gcm_context ctx;
22853  unsigned int key_len;
22854  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
22855  int ret;
22856 
22857  memset(key_str, 0x00, 128);
22858  memset(src_str, 0x00, 128);
22859  memset(dst_str, 0x00, 257);
22860  memset(iv_str, 0x00, 128);
22861  memset(add_str, 0x00, 128);
22862  memset(tag_str, 0x00, 128);
22863  memset(output, 0x00, 128);
22864 
22865  key_len = unhexify( key_str, "3ab1d9bb571c4bdc9f3ef340914bddcfe0c8e7718d4a2530334372cec86e5fcb" );
22866  pt_len = unhexify( src_str, "80bcea307e009745724d5f15d21f3b61a5d5a8401530346b34a2adfa13e3e8c9c9327d6fad914b081e554fbe6c1c6fe070b566620e559555c702c0ab5becf61ea1d9de64351ce43b2276ef4e20b5af7ce43db6d21286af4e740ef00c6d790705afcf0ee4850fffc12c662f2bd8212feb21db31065ab8f717a7509c213352b869" );
22867  iv_len = unhexify( iv_str, "6a5335901284dd3b64dc4a7f810bab96" );
22868  add_len = unhexify( add_str, "" );
22869  unhexify( tag_str, "04b8e5423aee8c06539f435edd" );
22870 
22871  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22872  if( 0 == 0 )
22873  {
22874  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22875 
22876  if( strcmp( "FAIL", "36b9602eee20b8f18dce0783cd1e01a799f81ae0a1ce6d293a26c62f47e7dad85c8446697cc09c81d3d9ead6f9e55c4147211660c8aea9536cc5516e9883c7d6854be580af8cd47ba38fa8451f0dad9c904e0e7f9997eff7e29bf880cd7cedd79493a0e299efe644046e4a46bf6645dfb2397b3a482a346b215deb778c9b7636" ) == 0 )
22877  {
22878  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22879  }
22880  else
22881  {
22882  hexify( dst_str, output, pt_len );
22883 
22884  fct_chk( strcmp( (char *) dst_str, "36b9602eee20b8f18dce0783cd1e01a799f81ae0a1ce6d293a26c62f47e7dad85c8446697cc09c81d3d9ead6f9e55c4147211660c8aea9536cc5516e9883c7d6854be580af8cd47ba38fa8451f0dad9c904e0e7f9997eff7e29bf880cd7cedd79493a0e299efe644046e4a46bf6645dfb2397b3a482a346b215deb778c9b7636" ) == 0 );
22885  }
22886  }
22887  }
22888  FCT_TEST_END();
22889 
22890 
22891  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240104_1)
22892  {
22893  unsigned char key_str[128];
22894  unsigned char src_str[128];
22895  unsigned char dst_str[257];
22896  unsigned char iv_str[128];
22897  unsigned char add_str[128];
22898  unsigned char tag_str[128];
22899  unsigned char output[128];
22900  gcm_context ctx;
22901  unsigned int key_len;
22902  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
22903  int ret;
22904 
22905  memset(key_str, 0x00, 128);
22906  memset(src_str, 0x00, 128);
22907  memset(dst_str, 0x00, 257);
22908  memset(iv_str, 0x00, 128);
22909  memset(add_str, 0x00, 128);
22910  memset(tag_str, 0x00, 128);
22911  memset(output, 0x00, 128);
22912 
22913  key_len = unhexify( key_str, "7dddbd5657e22750bfe6baa70a1f4ac46c1ef8bee573a57cfcef50b66f85e593" );
22914  pt_len = unhexify( src_str, "2bf5aba83a8161b9d21ff29251fb0efa697b1ea9c1b3de8481d5fd4d6b57afda0b098decdc8278cc855f25da4116ed558fc4e665a49a8fff3aef11115757a99c10b5a73b1f794f9502186c13dc79442f9226bbf4df19a6440281f76184933aeae438a25f85dbd0781e020a9f7e29fb8e517f597719e639cbd6061ea3b4b67fb0" );
22915  iv_len = unhexify( iv_str, "fcb962c39e4850efc8ffd43d9cd960a6" );
22916  add_len = unhexify( add_str, "" );
22917  unhexify( tag_str, "1d8cdadcf1872fb2b697e82ef6" );
22918 
22919  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22920  if( 0 == 0 )
22921  {
22922  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22923 
22924  if( strcmp( "FAIL", "FAIL" ) == 0 )
22925  {
22926  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22927  }
22928  else
22929  {
22930  hexify( dst_str, output, pt_len );
22931 
22932  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
22933  }
22934  }
22935  }
22936  FCT_TEST_END();
22937 
22938 
22939  FCT_TEST_BGN(gcm_nist_validation_aes_25612810240104_2)
22940  {
22941  unsigned char key_str[128];
22942  unsigned char src_str[128];
22943  unsigned char dst_str[257];
22944  unsigned char iv_str[128];
22945  unsigned char add_str[128];
22946  unsigned char tag_str[128];
22947  unsigned char output[128];
22948  gcm_context ctx;
22949  unsigned int key_len;
22950  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
22951  int ret;
22952 
22953  memset(key_str, 0x00, 128);
22954  memset(src_str, 0x00, 128);
22955  memset(dst_str, 0x00, 257);
22956  memset(iv_str, 0x00, 128);
22957  memset(add_str, 0x00, 128);
22958  memset(tag_str, 0x00, 128);
22959  memset(output, 0x00, 128);
22960 
22961  key_len = unhexify( key_str, "6916b93b2712421f1f4582de7ec4237c4e42e2b32c7dced2f8bb5bd2e0598312" );
22962  pt_len = unhexify( src_str, "3739cca20279a36ddb857ac22beae901a49529b3182463ab81a7c46e437eb0b0571e8c16f7b626ecd9f2ca0cd83debe3f83e5d58ed3738899f4b616755eb57fb965208f261736bdf7648b1f8595c6b6a779768115e3077dfee7a42d44b555a51675fb1ce9961d0e21b2b9b477c0541184350e70decf7c14a4c24b8a6cd5fed8e" );
22963  iv_len = unhexify( iv_str, "b4d9248bb500e40de99ca2a13e743f1c" );
22964  add_len = unhexify( add_str, "" );
22965  unhexify( tag_str, "090d03446d65adcc0a42387e8e" );
22966 
22967  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
22968  if( 0 == 0 )
22969  {
22970  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
22971 
22972  if( strcmp( "FAIL", "0255be7ac7ac6feb3a21f572f6a593cc8a97f17af7064c80e478f4a6c469cf94d604bc014b003bf284d216161a9c8a493af43c6a0d8caf813a9e6f83c7ed56dd57543876b11f76aa2be80dcd79d19ac61f00fa423ac2f52fae7a8327cd91494ca4116feb735980ad0a4b1445cb7f38cc712b8aee72179e65b97fca38694e3670" ) == 0 )
22973  {
22974  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
22975  }
22976  else
22977  {
22978  hexify( dst_str, output, pt_len );
22979 
22980  fct_chk( strcmp( (char *) dst_str, "0255be7ac7ac6feb3a21f572f6a593cc8a97f17af7064c80e478f4a6c469cf94d604bc014b003bf284d216161a9c8a493af43c6a0d8caf813a9e6f83c7ed56dd57543876b11f76aa2be80dcd79d19ac61f00fa423ac2f52fae7a8327cd91494ca4116feb735980ad0a4b1445cb7f38cc712b8aee72179e65b97fca38694e3670" ) == 0 );
22981  }
22982  }
22983  }
22984  FCT_TEST_END();
22985 
22986 
22987  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024096_0)
22988  {
22989  unsigned char key_str[128];
22990  unsigned char src_str[128];
22991  unsigned char dst_str[257];
22992  unsigned char iv_str[128];
22993  unsigned char add_str[128];
22994  unsigned char tag_str[128];
22995  unsigned char output[128];
22996  gcm_context ctx;
22997  unsigned int key_len;
22998  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
22999  int ret;
23000 
23001  memset(key_str, 0x00, 128);
23002  memset(src_str, 0x00, 128);
23003  memset(dst_str, 0x00, 257);
23004  memset(iv_str, 0x00, 128);
23005  memset(add_str, 0x00, 128);
23006  memset(tag_str, 0x00, 128);
23007  memset(output, 0x00, 128);
23008 
23009  key_len = unhexify( key_str, "b751c8b724165009a8bd97a9d2a0e22cae5a95c4743c55eeeef0a6fe7d946bec" );
23010  pt_len = unhexify( src_str, "e8546a5af1e38114822e60e75563a9399c88796f303c99c69d1f3c50379da81e1cd5b5a4a721e23c59da58ea4361b7ff58408e506a27fea24f9a235c6af7f7a5bd93fa31e90edfc322821c08d6324134830b7fe160b4a3e6d27866a10e6e60762a31618ef92f5c67ccb1deb1f1b188f0e687165e7c366c7418920df4f4fcdcae" );
23011  iv_len = unhexify( iv_str, "160c50c0621c03fd1572df6ba49f0d1e" );
23012  add_len = unhexify( add_str, "" );
23013  unhexify( tag_str, "9fef9becf21901496772996f" );
23014 
23015  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23016  if( 0 == 0 )
23017  {
23018  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23019 
23020  if( strcmp( "FAIL", "175fa6b7cd781ec057ff78ba410f2897a920739b5fc4f04bc9b998fbc7cc18e327ad44d59b167e4627256aaecd97dc3e4a7c9baaf51d177787a7f4a0a2d207a855753c4754d41348982d9418b6b24b590632d5115dc186b0ba3bec16b41fa47c0077c5d091ec705e554475024814c5167121dd224c544686398df3f33c210e82" ) == 0 )
23021  {
23022  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23023  }
23024  else
23025  {
23026  hexify( dst_str, output, pt_len );
23027 
23028  fct_chk( strcmp( (char *) dst_str, "175fa6b7cd781ec057ff78ba410f2897a920739b5fc4f04bc9b998fbc7cc18e327ad44d59b167e4627256aaecd97dc3e4a7c9baaf51d177787a7f4a0a2d207a855753c4754d41348982d9418b6b24b590632d5115dc186b0ba3bec16b41fa47c0077c5d091ec705e554475024814c5167121dd224c544686398df3f33c210e82" ) == 0 );
23029  }
23030  }
23031  }
23032  FCT_TEST_END();
23033 
23034 
23035  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024096_1)
23036  {
23037  unsigned char key_str[128];
23038  unsigned char src_str[128];
23039  unsigned char dst_str[257];
23040  unsigned char iv_str[128];
23041  unsigned char add_str[128];
23042  unsigned char tag_str[128];
23043  unsigned char output[128];
23044  gcm_context ctx;
23045  unsigned int key_len;
23046  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
23047  int ret;
23048 
23049  memset(key_str, 0x00, 128);
23050  memset(src_str, 0x00, 128);
23051  memset(dst_str, 0x00, 257);
23052  memset(iv_str, 0x00, 128);
23053  memset(add_str, 0x00, 128);
23054  memset(tag_str, 0x00, 128);
23055  memset(output, 0x00, 128);
23056 
23057  key_len = unhexify( key_str, "0faf32c22c2a4ee38fe4b5ce08f98fdf6f83b5038dcba5ec8332b3eeb5c710c7" );
23058  pt_len = unhexify( src_str, "8a556cc30075753c6e94c2f669bca2058ff6abcbffffc82da7cfca0a45af82dfb4cf487ceb4ede72be87ee4c8b72db1e96459de1dc96721464c544c001d785f2188b9fccaec4b1a37970d38b326f30163d2fdfdf8a2ce74aec55abcd823772b54f8081d086a2e7b17b4086d6c4a5ea67828ef0b593ea1387b2c61f5dfe8f2bb0" );
23059  iv_len = unhexify( iv_str, "04885a5846f5f75a760193de7f07853c" );
23060  add_len = unhexify( add_str, "" );
23061  unhexify( tag_str, "0c13506ed9f082dd08434342" );
23062 
23063  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23064  if( 0 == 0 )
23065  {
23066  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23067 
23068  if( strcmp( "FAIL", "FAIL" ) == 0 )
23069  {
23070  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23071  }
23072  else
23073  {
23074  hexify( dst_str, output, pt_len );
23075 
23076  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
23077  }
23078  }
23079  }
23080  FCT_TEST_END();
23081 
23082 
23083  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024096_2)
23084  {
23085  unsigned char key_str[128];
23086  unsigned char src_str[128];
23087  unsigned char dst_str[257];
23088  unsigned char iv_str[128];
23089  unsigned char add_str[128];
23090  unsigned char tag_str[128];
23091  unsigned char output[128];
23092  gcm_context ctx;
23093  unsigned int key_len;
23094  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
23095  int ret;
23096 
23097  memset(key_str, 0x00, 128);
23098  memset(src_str, 0x00, 128);
23099  memset(dst_str, 0x00, 257);
23100  memset(iv_str, 0x00, 128);
23101  memset(add_str, 0x00, 128);
23102  memset(tag_str, 0x00, 128);
23103  memset(output, 0x00, 128);
23104 
23105  key_len = unhexify( key_str, "0dddc3d2f82bdcdbc37648a6b9b416af28753740f8e998cd1a52a0b665369f1c" );
23106  pt_len = unhexify( src_str, "07bf84b15b21951fd22049be6991a672503ae243b8d285fb1e515e1d2c36bfd5b0d0bcce85791f2cea8f616aed68a7d9cf4eaf76418e8b1ec27751de67cbfd9d9f7905b2667904f10d598503f04c04ea00a681ff89a9c446d5763898430bd7a9dfebfe544e3ed3e639b362683a651e087626ffa63c0c2b3e0dd088b81b07f75e" );
23107  iv_len = unhexify( iv_str, "0a93b883cbd42998ae2e39aab342cb28" );
23108  add_len = unhexify( add_str, "" );
23109  unhexify( tag_str, "5c37918edb7aa65b246fd5a6" );
23110 
23111  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23112  if( 0 == 0 )
23113  {
23114  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23115 
23116  if( strcmp( "FAIL", "ff7b7b2f88b8c6f9f9bad7152874e995eea0ff1ce1ecd9b8d563642a37a31499f14d70f0dd835b7adf80928497f845fd8c2786cd53af25f8c9fe1bba24e3c3860162635bbed58f06cf6c9966bb9b570987a48329279bb84afb9e464bb4ad19ae6600175086e28929569027c5285d2ed97615e5a7dada40ba03c440861f524475" ) == 0 )
23117  {
23118  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23119  }
23120  else
23121  {
23122  hexify( dst_str, output, pt_len );
23123 
23124  fct_chk( strcmp( (char *) dst_str, "ff7b7b2f88b8c6f9f9bad7152874e995eea0ff1ce1ecd9b8d563642a37a31499f14d70f0dd835b7adf80928497f845fd8c2786cd53af25f8c9fe1bba24e3c3860162635bbed58f06cf6c9966bb9b570987a48329279bb84afb9e464bb4ad19ae6600175086e28929569027c5285d2ed97615e5a7dada40ba03c440861f524475" ) == 0 );
23125  }
23126  }
23127  }
23128  FCT_TEST_END();
23129 
23130 
23131  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024064_0)
23132  {
23133  unsigned char key_str[128];
23134  unsigned char src_str[128];
23135  unsigned char dst_str[257];
23136  unsigned char iv_str[128];
23137  unsigned char add_str[128];
23138  unsigned char tag_str[128];
23139  unsigned char output[128];
23140  gcm_context ctx;
23141  unsigned int key_len;
23142  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
23143  int ret;
23144 
23145  memset(key_str, 0x00, 128);
23146  memset(src_str, 0x00, 128);
23147  memset(dst_str, 0x00, 257);
23148  memset(iv_str, 0x00, 128);
23149  memset(add_str, 0x00, 128);
23150  memset(tag_str, 0x00, 128);
23151  memset(output, 0x00, 128);
23152 
23153  key_len = unhexify( key_str, "a0b1a62e46e7712277fc711e19d0c0c865ee77b42ac964b7202dbcaf428086c2" );
23154  pt_len = unhexify( src_str, "7dd7c0787fdbea4aacf929341659dcf4b75cbca8f92001e8b62a4d7b40272c5755fa9c445857db05328dc11ce5221f044f4b3dafbf0e2d72a1ad0d3e4c804148db578218690ccc620d8b97b4450ff83400a6caaa959617611446a6627138a4067be9ea410d4b0581022ab621928205b4a4480560fc4c2c3b39a2805684006f35" );
23155  iv_len = unhexify( iv_str, "e20957a49a27e247d00379850f934d6c" );
23156  add_len = unhexify( add_str, "" );
23157  unhexify( tag_str, "c99751516620bf89" );
23158 
23159  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23160  if( 0 == 0 )
23161  {
23162  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23163 
23164  if( strcmp( "FAIL", "9307620479f076c39f53965c87d20c2aff11c736c040dba74cd690d275591a5defc57a02f6806de82eb7051548589484364f6c9b91f233a87258ede1ee276cb2c93b4fc76f4d7e60cbd29ba2c54cb479c178fa462c1c2fb6eeb3f1df0edfb894c9222b994c4931dedf7c6e8ddecbde385ddf4481807f52322a47bf5ff7272991" ) == 0 )
23165  {
23166  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23167  }
23168  else
23169  {
23170  hexify( dst_str, output, pt_len );
23171 
23172  fct_chk( strcmp( (char *) dst_str, "9307620479f076c39f53965c87d20c2aff11c736c040dba74cd690d275591a5defc57a02f6806de82eb7051548589484364f6c9b91f233a87258ede1ee276cb2c93b4fc76f4d7e60cbd29ba2c54cb479c178fa462c1c2fb6eeb3f1df0edfb894c9222b994c4931dedf7c6e8ddecbde385ddf4481807f52322a47bf5ff7272991" ) == 0 );
23173  }
23174  }
23175  }
23176  FCT_TEST_END();
23177 
23178 
23179  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024064_1)
23180  {
23181  unsigned char key_str[128];
23182  unsigned char src_str[128];
23183  unsigned char dst_str[257];
23184  unsigned char iv_str[128];
23185  unsigned char add_str[128];
23186  unsigned char tag_str[128];
23187  unsigned char output[128];
23188  gcm_context ctx;
23189  unsigned int key_len;
23190  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
23191  int ret;
23192 
23193  memset(key_str, 0x00, 128);
23194  memset(src_str, 0x00, 128);
23195  memset(dst_str, 0x00, 257);
23196  memset(iv_str, 0x00, 128);
23197  memset(add_str, 0x00, 128);
23198  memset(tag_str, 0x00, 128);
23199  memset(output, 0x00, 128);
23200 
23201  key_len = unhexify( key_str, "ffcc1c88fba1723b3ab57b458d9bffb98b878c967fb43b9db2ae0753d32a3bb1" );
23202  pt_len = unhexify( src_str, "19b6dec86d93c466307de3a36c0791ed1010b1b9cf8d30347ae46e0f9283c9fda43da8cb491dd17cc4298b1f0b876d6a0f4bcbc9667fe34564bc08f8f7b67045057d19f4bf027bc839e590822fa09a5cef1af18e64a0116aa2a01a3f246c2b5272c18c9aa23efe674ba53d533ae8f0695cb78c1155cdc7a9d7fae2c4567dc07c" );
23203  iv_len = unhexify( iv_str, "d533c2170c5dc203512c81c34eff4077" );
23204  add_len = unhexify( add_str, "" );
23205  unhexify( tag_str, "167ec8675e7f9e12" );
23206 
23207  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23208  if( 0 == 0 )
23209  {
23210  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23211 
23212  if( strcmp( "FAIL", "0539287ac546fe5342e4c3c0ec07127dcd22899abfe8cdd6e89d08f1374d76e877bec4844d06e0a9f32d181c8d945ba16a54ce3725fae21d8245c070a4da0c646203d6b91325b665ab98c30295851c59265b4ab567b968b6e98536b7850738d92e9627b4c9c6f5d9ae2520944783d8f788a1aa11f3f5245660d41f388e26e0a1" ) == 0 )
23213  {
23214  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23215  }
23216  else
23217  {
23218  hexify( dst_str, output, pt_len );
23219 
23220  fct_chk( strcmp( (char *) dst_str, "0539287ac546fe5342e4c3c0ec07127dcd22899abfe8cdd6e89d08f1374d76e877bec4844d06e0a9f32d181c8d945ba16a54ce3725fae21d8245c070a4da0c646203d6b91325b665ab98c30295851c59265b4ab567b968b6e98536b7850738d92e9627b4c9c6f5d9ae2520944783d8f788a1aa11f3f5245660d41f388e26e0a1" ) == 0 );
23221  }
23222  }
23223  }
23224  FCT_TEST_END();
23225 
23226 
23227  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024064_2)
23228  {
23229  unsigned char key_str[128];
23230  unsigned char src_str[128];
23231  unsigned char dst_str[257];
23232  unsigned char iv_str[128];
23233  unsigned char add_str[128];
23234  unsigned char tag_str[128];
23235  unsigned char output[128];
23236  gcm_context ctx;
23237  unsigned int key_len;
23238  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
23239  int ret;
23240 
23241  memset(key_str, 0x00, 128);
23242  memset(src_str, 0x00, 128);
23243  memset(dst_str, 0x00, 257);
23244  memset(iv_str, 0x00, 128);
23245  memset(add_str, 0x00, 128);
23246  memset(tag_str, 0x00, 128);
23247  memset(output, 0x00, 128);
23248 
23249  key_len = unhexify( key_str, "55e94b339c3bafe068ef9cc30787cc6705850114976843777c92b4b331801650" );
23250  pt_len = unhexify( src_str, "147cc7bc4008dadf1956520b5998d961499bdf3d8b168591adbfd99411ad7b34eb4b2a5c1bb0522b810fec12dd7c775784d7ecdc741e6dec8191361e6abf473b219221801951b4d5ffe955ab50eef9cffdfee65ba29ddfa943fb52d722825338c307870a48a35f51db340aa946c71904d03174b1e4a498238b9d631a6982c68d" );
23251  iv_len = unhexify( iv_str, "2e2b31214d61276a54daf2ccb98baa36" );
23252  add_len = unhexify( add_str, "" );
23253  unhexify( tag_str, "5266e9c67c252164" );
23254 
23255  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23256  if( 0 == 0 )
23257  {
23258  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23259 
23260  if( strcmp( "FAIL", "FAIL" ) == 0 )
23261  {
23262  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23263  }
23264  else
23265  {
23266  hexify( dst_str, output, pt_len );
23267 
23268  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
23269  }
23270  }
23271  }
23272  FCT_TEST_END();
23273 
23274 
23275  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024032_0)
23276  {
23277  unsigned char key_str[128];
23278  unsigned char src_str[128];
23279  unsigned char dst_str[257];
23280  unsigned char iv_str[128];
23281  unsigned char add_str[128];
23282  unsigned char tag_str[128];
23283  unsigned char output[128];
23284  gcm_context ctx;
23285  unsigned int key_len;
23286  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
23287  int ret;
23288 
23289  memset(key_str, 0x00, 128);
23290  memset(src_str, 0x00, 128);
23291  memset(dst_str, 0x00, 257);
23292  memset(iv_str, 0x00, 128);
23293  memset(add_str, 0x00, 128);
23294  memset(tag_str, 0x00, 128);
23295  memset(output, 0x00, 128);
23296 
23297  key_len = unhexify( key_str, "13c9572bdef62510d84f2d415cc481cd1e71b9c1132b43e63b21ba4e16de9b39" );
23298  pt_len = unhexify( src_str, "7c78e634dec811173ff3c4a9a48ae3ae794fbd2aefd4b31701777ff6fcb670744c592a1d298d319717870dca364b2a3562a4ffa422bf7173c4f7ea9b0edf675e948f8370ffd0fd0d5703a9d33e8f9f375b8b641a1b1eecd1692ad1d461a68d97f91f9087f213aff23db1246ee16f403969c238f99eed894658277da23ced11ee" );
23299  iv_len = unhexify( iv_str, "a8339ba505a14786ad05edfe8cebb8d0" );
23300  add_len = unhexify( add_str, "" );
23301  unhexify( tag_str, "df3cab08" );
23302 
23303  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23304  if( 0 == 0 )
23305  {
23306  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23307 
23308  if( strcmp( "FAIL", "91f9780daefd2c1010c458054ac6e35baa885cdd2c95e28e13f84451064e31e0739f27bf259cb376ab951e1c7048e1252f0849ccb5453fc97b319666ebbfbc7ef3055212a61582d1b69158f3b1629950a41bc756bded20498492ebc49a1535d1bd915e59c49b87ffebea2f4ad4516ecdd63fa5afda9cce9dc730d6ab2757384a" ) == 0 )
23309  {
23310  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23311  }
23312  else
23313  {
23314  hexify( dst_str, output, pt_len );
23315 
23316  fct_chk( strcmp( (char *) dst_str, "91f9780daefd2c1010c458054ac6e35baa885cdd2c95e28e13f84451064e31e0739f27bf259cb376ab951e1c7048e1252f0849ccb5453fc97b319666ebbfbc7ef3055212a61582d1b69158f3b1629950a41bc756bded20498492ebc49a1535d1bd915e59c49b87ffebea2f4ad4516ecdd63fa5afda9cce9dc730d6ab2757384a" ) == 0 );
23317  }
23318  }
23319  }
23320  FCT_TEST_END();
23321 
23322 
23323  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024032_1)
23324  {
23325  unsigned char key_str[128];
23326  unsigned char src_str[128];
23327  unsigned char dst_str[257];
23328  unsigned char iv_str[128];
23329  unsigned char add_str[128];
23330  unsigned char tag_str[128];
23331  unsigned char output[128];
23332  gcm_context ctx;
23333  unsigned int key_len;
23334  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
23335  int ret;
23336 
23337  memset(key_str, 0x00, 128);
23338  memset(src_str, 0x00, 128);
23339  memset(dst_str, 0x00, 257);
23340  memset(iv_str, 0x00, 128);
23341  memset(add_str, 0x00, 128);
23342  memset(tag_str, 0x00, 128);
23343  memset(output, 0x00, 128);
23344 
23345  key_len = unhexify( key_str, "30a14ca53913acbb215b4e4159083106db3fff83cbedd1e5425f65af1e94f5dd" );
23346  pt_len = unhexify( src_str, "8c5f73ee1544553b712ad7a14f31379c8d54a4e432fb6c5112436988d83c4e94954b0249b470538fb977b756fbee70b811d4dc047a869e207bb0b495f1e271d0034e912000e97594033e0dedde0591b297f8a84bafcc93a46268a5bba117b558f1c73513e971c80a7083e1718fc12d0cc0d996a8e09603d564f0b8e81eea28bc" );
23347  iv_len = unhexify( iv_str, "4f23f04904de76d6decd4bd380ff56b1" );
23348  add_len = unhexify( add_str, "" );
23349  unhexify( tag_str, "18e92b96" );
23350 
23351  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23352  if( 0 == 0 )
23353  {
23354  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23355 
23356  if( strcmp( "FAIL", "bb4b3f8061edd6fa418dd71fe22eb0528547050b3bfbaa1c74e82148470d557499ce856de3e988384c0a73671bf370e560d8fda96dabe4728b5f72a6f9efd5023b07a96a631cafdf2c878b2567104c466f82b89f429915cf3331845febcff008558f836b4c12d53e94d363eae43a50fc6cb36f4ca183be92ca5f299704e2c8cf" ) == 0 )
23357  {
23358  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23359  }
23360  else
23361  {
23362  hexify( dst_str, output, pt_len );
23363 
23364  fct_chk( strcmp( (char *) dst_str, "bb4b3f8061edd6fa418dd71fe22eb0528547050b3bfbaa1c74e82148470d557499ce856de3e988384c0a73671bf370e560d8fda96dabe4728b5f72a6f9efd5023b07a96a631cafdf2c878b2567104c466f82b89f429915cf3331845febcff008558f836b4c12d53e94d363eae43a50fc6cb36f4ca183be92ca5f299704e2c8cf" ) == 0 );
23365  }
23366  }
23367  }
23368  FCT_TEST_END();
23369 
23370 
23371  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024032_2)
23372  {
23373  unsigned char key_str[128];
23374  unsigned char src_str[128];
23375  unsigned char dst_str[257];
23376  unsigned char iv_str[128];
23377  unsigned char add_str[128];
23378  unsigned char tag_str[128];
23379  unsigned char output[128];
23380  gcm_context ctx;
23381  unsigned int key_len;
23382  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
23383  int ret;
23384 
23385  memset(key_str, 0x00, 128);
23386  memset(src_str, 0x00, 128);
23387  memset(dst_str, 0x00, 257);
23388  memset(iv_str, 0x00, 128);
23389  memset(add_str, 0x00, 128);
23390  memset(tag_str, 0x00, 128);
23391  memset(output, 0x00, 128);
23392 
23393  key_len = unhexify( key_str, "e69f419140289ac25fb0e2ef9cc4f7e06777ac20f7d631918d1af0c8883b7d6a" );
23394  pt_len = unhexify( src_str, "ff8dfa4e70490ea9c84cb894dc5d7e1b935ebcdea80a39c4161d4db42cbb269cc86abd381af15ec9a4a42ed18c1eed540decec19722df46f22aa06883297cb393fb23e4bb31a817e88357aa923c7ecbcf24c28a09f622dd21fa70c0a02193024fdcefeaa96cc1b50f81a65dfa9e1bb5126f0c9766a861eed096ec15fb07b0f81" );
23395  iv_len = unhexify( iv_str, "531248afdaaf1b86cf34d2394900afd9" );
23396  add_len = unhexify( add_str, "" );
23397  unhexify( tag_str, "c6885cdd" );
23398 
23399  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23400  if( 0 == 0 )
23401  {
23402  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23403 
23404  if( strcmp( "FAIL", "f75299e0ead3834fc7ebd4b2051541b598ad57cc908fdcd4324cf4ccf7dcf7b3f0737ad6c026399a8b1b6d3d50011b3c48ea2c89833b4b44c437677f230b75d36848781d4af14546894eecd873a2b1c3d2fcdd676b10bd55112038c0fdaa7b5598fe4db273a1b6744cba47189b7e2a973651bfc2aaa9e9abea4494047b957a80" ) == 0 )
23405  {
23406  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23407  }
23408  else
23409  {
23410  hexify( dst_str, output, pt_len );
23411 
23412  fct_chk( strcmp( (char *) dst_str, "f75299e0ead3834fc7ebd4b2051541b598ad57cc908fdcd4324cf4ccf7dcf7b3f0737ad6c026399a8b1b6d3d50011b3c48ea2c89833b4b44c437677f230b75d36848781d4af14546894eecd873a2b1c3d2fcdd676b10bd55112038c0fdaa7b5598fe4db273a1b6744cba47189b7e2a973651bfc2aaa9e9abea4494047b957a80" ) == 0 );
23413  }
23414  }
23415  }
23416  FCT_TEST_END();
23417 
23418 
23419  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024128_0)
23420  {
23421  unsigned char key_str[128];
23422  unsigned char src_str[128];
23423  unsigned char dst_str[257];
23424  unsigned char iv_str[128];
23425  unsigned char add_str[128];
23426  unsigned char tag_str[128];
23427  unsigned char output[128];
23428  gcm_context ctx;
23429  unsigned int key_len;
23430  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
23431  int ret;
23432 
23433  memset(key_str, 0x00, 128);
23434  memset(src_str, 0x00, 128);
23435  memset(dst_str, 0x00, 257);
23436  memset(iv_str, 0x00, 128);
23437  memset(add_str, 0x00, 128);
23438  memset(tag_str, 0x00, 128);
23439  memset(output, 0x00, 128);
23440 
23441  key_len = unhexify( key_str, "404a5d1ac9e32f9caabffbfa485ce9c27edc9e5cde0f2aab4f32ce3121449b88" );
23442  pt_len = unhexify( src_str, "b63ec4d28854b7fe2d4d13973f5bcb16f78494ce25cc2820de9d0dc1d8d91db1f19bc9e01cee8418c9e88a69b2f30cdbb0dbdbb50be71e1e666c111c126f2b7197c02f69a1b2ec5e1bf4062b2d0b22fb0fa1585b4e6286b29f6ac98d1b1319dd99851fa6921607077d2947140fdeeea145b56ea7b6af276c9f65393bc43ede33" );
23443  iv_len = unhexify( iv_str, "b6e6c078e6869df156faa9ac32f057c3" );
23444  add_len = unhexify( add_str, "6ebc75fc9304f2b139abc7d3f68b253228009c503a08b7be77852da9e1afbe72c9ab374740b0dc391fa4d7e17de6a0aa08c69e6f5c5f05411e71e70c69dfbcf693df84c30f7a8e6c7949ea1e734297c0ea3df9b7e905faa6bbdcaf1ff2625a39363308331d74892cf531cb3f6d7db31bbe9a039fca87100367747024f68c5b77" );
23445  unhexify( tag_str, "94c1b9b70f9c48e7efd40ecab320c2d3" );
23446 
23447  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23448  if( 0 == 0 )
23449  {
23450  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23451 
23452  if( strcmp( "FAIL", "56a0ac94f3ec7be2608154f779c434ee96db5ed4f5a6e1acfb32361ce04e16e1337be5978df06d7c4f6012385fb9d45bb397dc00f165883714b4a5b2f72f69c018ffa6d4420ad1b772e94575f035ad203be3d34b5b789a99389f295b43f004de3daaef7fa918712d3a23ca44329595e08da190e3678bc6ad9b500b9f885abe23" ) == 0 )
23453  {
23454  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23455  }
23456  else
23457  {
23458  hexify( dst_str, output, pt_len );
23459 
23460  fct_chk( strcmp( (char *) dst_str, "56a0ac94f3ec7be2608154f779c434ee96db5ed4f5a6e1acfb32361ce04e16e1337be5978df06d7c4f6012385fb9d45bb397dc00f165883714b4a5b2f72f69c018ffa6d4420ad1b772e94575f035ad203be3d34b5b789a99389f295b43f004de3daaef7fa918712d3a23ca44329595e08da190e3678bc6ad9b500b9f885abe23" ) == 0 );
23461  }
23462  }
23463  }
23464  FCT_TEST_END();
23465 
23466 
23467  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024128_1)
23468  {
23469  unsigned char key_str[128];
23470  unsigned char src_str[128];
23471  unsigned char dst_str[257];
23472  unsigned char iv_str[128];
23473  unsigned char add_str[128];
23474  unsigned char tag_str[128];
23475  unsigned char output[128];
23476  gcm_context ctx;
23477  unsigned int key_len;
23478  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
23479  int ret;
23480 
23481  memset(key_str, 0x00, 128);
23482  memset(src_str, 0x00, 128);
23483  memset(dst_str, 0x00, 257);
23484  memset(iv_str, 0x00, 128);
23485  memset(add_str, 0x00, 128);
23486  memset(tag_str, 0x00, 128);
23487  memset(output, 0x00, 128);
23488 
23489  key_len = unhexify( key_str, "b56f0c980acf7875cf7f27d53ad4a276adc126d0b93a5774ac4277eecad4309e" );
23490  pt_len = unhexify( src_str, "2c94299e36b7c4a825ecbc5a7809061e0a6761764a5a655ffdb0c20e5c3fcb10f4e93c68aa0a38c2acc5d06f2b7c4ff4fcf814b551bfefa248dbe06a09a0f153213538a31fa7cf7d646b5b53908d8978f514c9c4d6d66f2b3738024b5f9c3fd86b6da0c818203183f4205f186ea44a54edb911b1a17c424c95852c8d271b2e93" );
23491  iv_len = unhexify( iv_str, "b004c049decfb43d6f3ec13c56f839ef" );
23492  add_len = unhexify( add_str, "b2045b97fbb52a5fc6ff03d74e59dd696f3f442c0b555add8e6d111f835df420f45e970c4b32a84f0c45ba3710b5cd574001862b073efa5c9c4bd50127b2ce72d2c736c5e2723956da5a0acb82041a609386d07b50551c1d1fa4678886bac54b0bd080cc5ef607dca2a0d6a1e71f0e3833678bf8560bc059dae370ec94d43af6" );
23493  unhexify( tag_str, "fce7234f7f76b5d502fd2b96fc9b1ce7" );
23494 
23495  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23496  if( 0 == 0 )
23497  {
23498  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23499 
23500  if( strcmp( "FAIL", "FAIL" ) == 0 )
23501  {
23502  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23503  }
23504  else
23505  {
23506  hexify( dst_str, output, pt_len );
23507 
23508  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
23509  }
23510  }
23511  }
23512  FCT_TEST_END();
23513 
23514 
23515  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024128_2)
23516  {
23517  unsigned char key_str[128];
23518  unsigned char src_str[128];
23519  unsigned char dst_str[257];
23520  unsigned char iv_str[128];
23521  unsigned char add_str[128];
23522  unsigned char tag_str[128];
23523  unsigned char output[128];
23524  gcm_context ctx;
23525  unsigned int key_len;
23526  size_t pt_len, iv_len, add_len, tag_len = 128 / 8;
23527  int ret;
23528 
23529  memset(key_str, 0x00, 128);
23530  memset(src_str, 0x00, 128);
23531  memset(dst_str, 0x00, 257);
23532  memset(iv_str, 0x00, 128);
23533  memset(add_str, 0x00, 128);
23534  memset(tag_str, 0x00, 128);
23535  memset(output, 0x00, 128);
23536 
23537  key_len = unhexify( key_str, "1c5027c36e6caa1b3e5e45fead32b5e3126ac41f106c491b0b3a7c16502f4fe6" );
23538  pt_len = unhexify( src_str, "58f0ceaa31c0025d2e6bb58720cce4b64f5f6c657c847ae42936eb1e343fea397c8a8cf2f5ef02ffaec25f431900dcb0910cf32cea9eca3b78aed1c451c7af51066489f87b2a5f8cf28d6fdb6ce49d898b6167b590a3907be7618be11fb0922a3cfd18e73efef19e5cdc250fa33f61e3940c6482ae35f339e8c0a85a17379a4e" );
23539  iv_len = unhexify( iv_str, "3ee660f03858669e557e3effdd7df6bd" );
23540  add_len = unhexify( add_str, "93e803c79de6ad652def62cf3cd34f9addc9dd1774967a0f69e1d28361eb2cacc177c63c07657389ce23bbe65d73e0460946d31be495424655c7724eac044cafafe1540fcbd4218921367054e43e3d21e0fa6a0da9f8b20c5cdbd019c944a2d2ee6aa6760ee1131e58fec9da30790f5a873e792098a82ddf18c3813611d9242a" );
23541  unhexify( tag_str, "ac33f5ffca9df4efc09271ff7a4f58e2" );
23542 
23543  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23544  if( 0 == 0 )
23545  {
23546  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23547 
23548  if( strcmp( "FAIL", "FAIL" ) == 0 )
23549  {
23550  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23551  }
23552  else
23553  {
23554  hexify( dst_str, output, pt_len );
23555 
23556  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
23557  }
23558  }
23559  }
23560  FCT_TEST_END();
23561 
23562 
23563  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024120_0)
23564  {
23565  unsigned char key_str[128];
23566  unsigned char src_str[128];
23567  unsigned char dst_str[257];
23568  unsigned char iv_str[128];
23569  unsigned char add_str[128];
23570  unsigned char tag_str[128];
23571  unsigned char output[128];
23572  gcm_context ctx;
23573  unsigned int key_len;
23574  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
23575  int ret;
23576 
23577  memset(key_str, 0x00, 128);
23578  memset(src_str, 0x00, 128);
23579  memset(dst_str, 0x00, 257);
23580  memset(iv_str, 0x00, 128);
23581  memset(add_str, 0x00, 128);
23582  memset(tag_str, 0x00, 128);
23583  memset(output, 0x00, 128);
23584 
23585  key_len = unhexify( key_str, "34c3019810d72b5e584f0758f2f5888a42729a33610aafa9824badade4136bbd" );
23586  pt_len = unhexify( src_str, "22deef66cbb7db240c399b6c83407f090d6999ba25e560b2087fed0467904bb5c40cbaa05b8bf0ff5a77c53fa229478d8e0736414daf9c420417c391c9a523fd85954533f1304d81359bdcc2c4ac90d9f5f8a67a517d7f05ba0409b718159baf11cd9154e815d5745179beb59954a45a8676a375d5af7fae4d0da05c4ea91a13" );
23587  iv_len = unhexify( iv_str, "f315ea36c17fc57dab3a2737d687cd4f" );
23588  add_len = unhexify( add_str, "f33c5a3a9e546ad5b35e4febf2ae557ca767b55d93bb3c1cf62d862d112dbd26f8fe2a3f54d347c1bc30029e55118bab2662b99b984b8b8e2d76831f94e48587de2709e32f16c26695f07e654b703eba6428f30070e23ed40b61d04dd1430e33c629117d945d9c0e4d36c79a8b8ab555d85083a898e7e7fbeb64a45cc3511d99" );
23589  unhexify( tag_str, "0bae9403888efb4d8ec97df604cd5d" );
23590 
23591  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23592  if( 0 == 0 )
23593  {
23594  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23595 
23596  if( strcmp( "FAIL", "FAIL" ) == 0 )
23597  {
23598  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23599  }
23600  else
23601  {
23602  hexify( dst_str, output, pt_len );
23603 
23604  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
23605  }
23606  }
23607  }
23608  FCT_TEST_END();
23609 
23610 
23611  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024120_1)
23612  {
23613  unsigned char key_str[128];
23614  unsigned char src_str[128];
23615  unsigned char dst_str[257];
23616  unsigned char iv_str[128];
23617  unsigned char add_str[128];
23618  unsigned char tag_str[128];
23619  unsigned char output[128];
23620  gcm_context ctx;
23621  unsigned int key_len;
23622  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
23623  int ret;
23624 
23625  memset(key_str, 0x00, 128);
23626  memset(src_str, 0x00, 128);
23627  memset(dst_str, 0x00, 257);
23628  memset(iv_str, 0x00, 128);
23629  memset(add_str, 0x00, 128);
23630  memset(tag_str, 0x00, 128);
23631  memset(output, 0x00, 128);
23632 
23633  key_len = unhexify( key_str, "29397d98fc5a7f04b5c8b6aa3a1dd975b6e4678457ae7f0691eee40b5397503a" );
23634  pt_len = unhexify( src_str, "0bbf1079cb5569c32257bc7e52371db46f3961b457402b816588243b4523543430d5ca56b52de6632724c51e6c3af310b28822c749a12bdd58dee58bbc3266631562a998ec3acdc8a2567a9f07f7f9759c3f50b1d1dcdd529256b80c0d227fc1fe8b58c62d1c643f1ac2996809fd061afcf4a9af184c14db9e63ec885c49de61" );
23635  iv_len = unhexify( iv_str, "885543a45fd1163e34ef9276145b0f8c" );
23636  add_len = unhexify( add_str, "d88beaa0664bcef178cbdbfab17ff526b5c0f8ad9543c6a312d93c336707fbf87c0448b07a550580953279f552f368225cc6971f1eecc718d6aad1729c8d8873081357752bd09d77075fa680cb2dc4139171e4a0aaa50b28c262c14fd10b8d799ca1c6641bb7dfdfdf3dea69aa2b9e4e4726dc18b0784afa4228e5ccb1eb2422" );
23637  unhexify( tag_str, "7b334d7af54b916821f6136e977a1f" );
23638 
23639  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23640  if( 0 == 0 )
23641  {
23642  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23643 
23644  if( strcmp( "FAIL", "FAIL" ) == 0 )
23645  {
23646  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23647  }
23648  else
23649  {
23650  hexify( dst_str, output, pt_len );
23651 
23652  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
23653  }
23654  }
23655  }
23656  FCT_TEST_END();
23657 
23658 
23659  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024120_2)
23660  {
23661  unsigned char key_str[128];
23662  unsigned char src_str[128];
23663  unsigned char dst_str[257];
23664  unsigned char iv_str[128];
23665  unsigned char add_str[128];
23666  unsigned char tag_str[128];
23667  unsigned char output[128];
23668  gcm_context ctx;
23669  unsigned int key_len;
23670  size_t pt_len, iv_len, add_len, tag_len = 120 / 8;
23671  int ret;
23672 
23673  memset(key_str, 0x00, 128);
23674  memset(src_str, 0x00, 128);
23675  memset(dst_str, 0x00, 257);
23676  memset(iv_str, 0x00, 128);
23677  memset(add_str, 0x00, 128);
23678  memset(tag_str, 0x00, 128);
23679  memset(output, 0x00, 128);
23680 
23681  key_len = unhexify( key_str, "7555dfcf354da07fd70f951d94ec1d86a635edfdb7929460207b2a39cc0cf4a3" );
23682  pt_len = unhexify( src_str, "a1351cfffd1b0cbf80c3318cc432d3238cb647e996b7b53c527783594683f535950cd08788687c77226b2d3f095955884adc2e475ca1e1eab04e37d5e901ae8934a9d3a0cb37b80612ca25d989856dfa7607b03039b64d7dcd468204f03e0f2c55cb41c5367c56ca6c561425992b40e2d4f380b3d8419f681e88ebe2d4bdad36" );
23683  iv_len = unhexify( iv_str, "e1b30b6a47e8c21228e41a21b1a004f0" );
23684  add_len = unhexify( add_str, "bf986d3842378440f8924bb7f117d1a86888a666915a93ba65d486d14c580501e736d3418cebee572439318b21b6e4e504a7b075b8c2300c014e87e04fa842b6a2a3ebd9e6134b9ddd78e0a696223b1dc775f3288a6a9569c64b4d8fc5e04f2047c70115f692d2c2cefe7488de42ff862d7c0f542e58d69f0f8c9bf67ef48aea" );
23685  unhexify( tag_str, "d8ef5438b7cf5dc11209a635ce1095" );
23686 
23687  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23688  if( 0 == 0 )
23689  {
23690  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23691 
23692  if( strcmp( "FAIL", "95e8db7c8ecab8a60ceb49726153a7c5553cf571bc40515944d833485e19bf33cb954e2555943778040165a6cfffecef79eb7d82fef5a2f136f004bb5e7c35ae827fac3da292a185b5b8fc262012c05caeda5453ede3303cfeb0c890db1facadaa2895bdbb33265ada0bb46030607b6cf94f86961178e2e2deeb53c63900f1ec" ) == 0 )
23693  {
23694  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23695  }
23696  else
23697  {
23698  hexify( dst_str, output, pt_len );
23699 
23700  fct_chk( strcmp( (char *) dst_str, "95e8db7c8ecab8a60ceb49726153a7c5553cf571bc40515944d833485e19bf33cb954e2555943778040165a6cfffecef79eb7d82fef5a2f136f004bb5e7c35ae827fac3da292a185b5b8fc262012c05caeda5453ede3303cfeb0c890db1facadaa2895bdbb33265ada0bb46030607b6cf94f86961178e2e2deeb53c63900f1ec" ) == 0 );
23701  }
23702  }
23703  }
23704  FCT_TEST_END();
23705 
23706 
23707  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024112_0)
23708  {
23709  unsigned char key_str[128];
23710  unsigned char src_str[128];
23711  unsigned char dst_str[257];
23712  unsigned char iv_str[128];
23713  unsigned char add_str[128];
23714  unsigned char tag_str[128];
23715  unsigned char output[128];
23716  gcm_context ctx;
23717  unsigned int key_len;
23718  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
23719  int ret;
23720 
23721  memset(key_str, 0x00, 128);
23722  memset(src_str, 0x00, 128);
23723  memset(dst_str, 0x00, 257);
23724  memset(iv_str, 0x00, 128);
23725  memset(add_str, 0x00, 128);
23726  memset(tag_str, 0x00, 128);
23727  memset(output, 0x00, 128);
23728 
23729  key_len = unhexify( key_str, "bbeafe86c72ab0354b733b69b09e4d3462feb1658fe404004d81503f3a6e132f" );
23730  pt_len = unhexify( src_str, "a033c2051e425d01d97d563572e42c5113860e5dedcd24c76e3e357559ba3250f1fc5d4a931a9d0900ac025400f0158621f0b1215b2907467bfc874bcabbb28e28de81fe1ee5b79985261c512afec2327c8c5957df90c9eb77950de4a4860b57a9e6e145ea15eb52da63f217f94a5c8e5fcb5d361b86e0e67637a450cdbcb06f" );
23731  iv_len = unhexify( iv_str, "ee1caba93cb549054ca29715a536393e" );
23732  add_len = unhexify( add_str, "e44b0e0d275ae7c38a7dc2f768e899c1c11a4c4cb5b5bd25cd2132e3ecbaa5a63654312603e1c5b393c0ce6253c55986ee45bb1daac78a26749d88928f9b9908690fc148a656b78e3595319432763efbcf6957c9b2150ccabfd4833d0dcee01758c5efb47321a948b379a2ec0abcd6b6cbf41a8883f0f5d5bf7b240cb35f0777" );
23733  unhexify( tag_str, "a4809e072f93deb7b77c52427095" );
23734 
23735  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23736  if( 0 == 0 )
23737  {
23738  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23739 
23740  if( strcmp( "FAIL", "e62adf9bbd92dd03cc5250251691f724c6ece1cb89d8c4daf31cc732a5420f6bedab71aab0238ba23bd7165ed1f692561ef457fd1d47413949405b6fc8e17922b17026d89d5830b383546ea516a56f3a1c45ec1251583ae880fa8985bd3dcc1d6a57b746971937bf370e76482238cc08c2c3b13258151e0a6475cc017f8a3d0e" ) == 0 )
23741  {
23742  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23743  }
23744  else
23745  {
23746  hexify( dst_str, output, pt_len );
23747 
23748  fct_chk( strcmp( (char *) dst_str, "e62adf9bbd92dd03cc5250251691f724c6ece1cb89d8c4daf31cc732a5420f6bedab71aab0238ba23bd7165ed1f692561ef457fd1d47413949405b6fc8e17922b17026d89d5830b383546ea516a56f3a1c45ec1251583ae880fa8985bd3dcc1d6a57b746971937bf370e76482238cc08c2c3b13258151e0a6475cc017f8a3d0e" ) == 0 );
23749  }
23750  }
23751  }
23752  FCT_TEST_END();
23753 
23754 
23755  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024112_1)
23756  {
23757  unsigned char key_str[128];
23758  unsigned char src_str[128];
23759  unsigned char dst_str[257];
23760  unsigned char iv_str[128];
23761  unsigned char add_str[128];
23762  unsigned char tag_str[128];
23763  unsigned char output[128];
23764  gcm_context ctx;
23765  unsigned int key_len;
23766  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
23767  int ret;
23768 
23769  memset(key_str, 0x00, 128);
23770  memset(src_str, 0x00, 128);
23771  memset(dst_str, 0x00, 257);
23772  memset(iv_str, 0x00, 128);
23773  memset(add_str, 0x00, 128);
23774  memset(tag_str, 0x00, 128);
23775  memset(output, 0x00, 128);
23776 
23777  key_len = unhexify( key_str, "6ad06c88dd4f3becf35eed95bb859be2406a1803a66e4332a74c5f75c09b9a01" );
23778  pt_len = unhexify( src_str, "2219c11672884b93d0290b6a7140feafe416461f1cdaf0b3aa64693d7db2eb10feae46aac7af549fa1b0abc78c11f8df7ee803ef70310fc3e67769f8b4bc64f81143a6ebf8bee9d386a8ede5d2cc0ed17985a3b7bb95191ef55e684690ccdc5ca504bc6eb28442b353861a034a43532c025f666e80be967a6b05b9dd3a91ff58" );
23779  iv_len = unhexify( iv_str, "07d8b4a6e77aef9018828b61e0fdf2a4" );
23780  add_len = unhexify( add_str, "cca1fd0278045dda80b847f0975b6cbf31e1910d2c99b4eb78c360d89133a1c52e66c5c3801824afc1f079d2b2b1c827199e83f680e59b9a7de9b15fa7b6848b5bf4e16a12ac1af4cf2b4d7bb45673c5e1241e9996440860a9204fc27cae46a991607bc5e7120d6c115ddcbdd02c022b262602139081e61eee4aba7193f13992" );
23781  unhexify( tag_str, "e3ede170386e76321a575c095966" );
23782 
23783  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23784  if( 0 == 0 )
23785  {
23786  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23787 
23788  if( strcmp( "FAIL", "FAIL" ) == 0 )
23789  {
23790  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23791  }
23792  else
23793  {
23794  hexify( dst_str, output, pt_len );
23795 
23796  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
23797  }
23798  }
23799  }
23800  FCT_TEST_END();
23801 
23802 
23803  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024112_2)
23804  {
23805  unsigned char key_str[128];
23806  unsigned char src_str[128];
23807  unsigned char dst_str[257];
23808  unsigned char iv_str[128];
23809  unsigned char add_str[128];
23810  unsigned char tag_str[128];
23811  unsigned char output[128];
23812  gcm_context ctx;
23813  unsigned int key_len;
23814  size_t pt_len, iv_len, add_len, tag_len = 112 / 8;
23815  int ret;
23816 
23817  memset(key_str, 0x00, 128);
23818  memset(src_str, 0x00, 128);
23819  memset(dst_str, 0x00, 257);
23820  memset(iv_str, 0x00, 128);
23821  memset(add_str, 0x00, 128);
23822  memset(tag_str, 0x00, 128);
23823  memset(output, 0x00, 128);
23824 
23825  key_len = unhexify( key_str, "87bbf7c15689e8c99a5a32a8ba0dfebcfe1989159807428cdd1f382c3ea95178" );
23826  pt_len = unhexify( src_str, "b77d3bf3b30b3e6e5c86cbfb7e5455f6480f423cc76834b4663d28d9f1eb5c40212634e3347668427f7848352ab789886f96682a568260bdaeb7de0aae2af36f5ae04f06c332b158d923706c1c6255c673feeadb6d30bfc901e60b92acd9ddd83ef98686c4d492f4a60e97af2541d470a6a6b21903441020ea7619cf28a06986" );
23827  iv_len = unhexify( iv_str, "2f19aa1f3a82a7398706953f01739da7" );
23828  add_len = unhexify( add_str, "590dbd230854aa2b5ac19fc3dc9453e5bb9637e47d97b92486a599bdafdfb27c3852e3d06a91429bb820eb12a5318ed8861ffe87d659c462ef167be22604facfa3afb601b2167989b9e3b2e5b59e7d07fda27ffccd450869d528410b0aff468f70cc10ef6723a74af6eebc1572c123a9b5a9aab748a31fa764716d3293ff5de7" );
23829  unhexify( tag_str, "5c43fc4dc959fabeebb188dbf3a5" );
23830 
23831  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23832  if( 0 == 0 )
23833  {
23834  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23835 
23836  if( strcmp( "FAIL", "FAIL" ) == 0 )
23837  {
23838  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23839  }
23840  else
23841  {
23842  hexify( dst_str, output, pt_len );
23843 
23844  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
23845  }
23846  }
23847  }
23848  FCT_TEST_END();
23849 
23850 
23851  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024104_0)
23852  {
23853  unsigned char key_str[128];
23854  unsigned char src_str[128];
23855  unsigned char dst_str[257];
23856  unsigned char iv_str[128];
23857  unsigned char add_str[128];
23858  unsigned char tag_str[128];
23859  unsigned char output[128];
23860  gcm_context ctx;
23861  unsigned int key_len;
23862  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
23863  int ret;
23864 
23865  memset(key_str, 0x00, 128);
23866  memset(src_str, 0x00, 128);
23867  memset(dst_str, 0x00, 257);
23868  memset(iv_str, 0x00, 128);
23869  memset(add_str, 0x00, 128);
23870  memset(tag_str, 0x00, 128);
23871  memset(output, 0x00, 128);
23872 
23873  key_len = unhexify( key_str, "24095a66b6eb0320ca75e2ab78e8496a45f4b000fc43436904c3e386fb852ed2" );
23874  pt_len = unhexify( src_str, "4690edc843e23d9d9b9a4dab8fa8193f8bf03897d3d29759e9dc9e0f8a970c0f5d4399b9f60461fe5cf439f9b0d54bbc075695e4d76b76298cc2b75bb3e0b516ee9ada93f77c4c002ba9fd163a1e4b377befb76c1e5ab8b3901f214c0a4c48bd2aa2f33560d46e2721a060d4671dc97633ff9bcd703bb0fbed9a4a2c259b53f3" );
23875  iv_len = unhexify( iv_str, "0955c1f0e271edca279e016074886f60" );
23876  add_len = unhexify( add_str, "f5160c75c449e6bb971e73b7d04ab9b9a85879f6eb2d67354af94a4f0ca339c0a03a5b9ede87a4ff6823b698113a38ae5327e6878c3ccc0e36d74fe07aa51c027c3b334812862bc660178f5d0f3e764c0b828a5e3f2e7d7a1185b7e79828304a7ad3ddcd724305484177e66f4f81e66afdc5bbee0ec174bff5eb3719482bd2d8" );
23877  unhexify( tag_str, "75a31347598f09fceeea6736fe" );
23878 
23879  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23880  if( 0 == 0 )
23881  {
23882  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23883 
23884  if( strcmp( "FAIL", "0dd2dca260325967267667ff3ccdc6d6b35648821a42090abba46282869bac4bdc20a8bee024bea18a07396c38dbb45d9481fedcc423a3928cfa78a2f0ae8eedb062add810bdbee77ddc26c29e4f9fda1ab336d04ef42947b05fbdb9bc4df79e37af951d19d6bf5e5cb34eef898f23642a9c4a9111ed0b7a08abeeefbbd45c23" ) == 0 )
23885  {
23886  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23887  }
23888  else
23889  {
23890  hexify( dst_str, output, pt_len );
23891 
23892  fct_chk( strcmp( (char *) dst_str, "0dd2dca260325967267667ff3ccdc6d6b35648821a42090abba46282869bac4bdc20a8bee024bea18a07396c38dbb45d9481fedcc423a3928cfa78a2f0ae8eedb062add810bdbee77ddc26c29e4f9fda1ab336d04ef42947b05fbdb9bc4df79e37af951d19d6bf5e5cb34eef898f23642a9c4a9111ed0b7a08abeeefbbd45c23" ) == 0 );
23893  }
23894  }
23895  }
23896  FCT_TEST_END();
23897 
23898 
23899  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024104_1)
23900  {
23901  unsigned char key_str[128];
23902  unsigned char src_str[128];
23903  unsigned char dst_str[257];
23904  unsigned char iv_str[128];
23905  unsigned char add_str[128];
23906  unsigned char tag_str[128];
23907  unsigned char output[128];
23908  gcm_context ctx;
23909  unsigned int key_len;
23910  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
23911  int ret;
23912 
23913  memset(key_str, 0x00, 128);
23914  memset(src_str, 0x00, 128);
23915  memset(dst_str, 0x00, 257);
23916  memset(iv_str, 0x00, 128);
23917  memset(add_str, 0x00, 128);
23918  memset(tag_str, 0x00, 128);
23919  memset(output, 0x00, 128);
23920 
23921  key_len = unhexify( key_str, "086b77b5731f971f0bf5b8227361b216746daf8b08c583ad38f114a64aa7877b" );
23922  pt_len = unhexify( src_str, "629317212ff8bd8a7676e4c00b81a9577de6397c832f99ac974fa2bbbccb6e3b8aa776db6922eed0b014bf3923799da7d9d0854c8817470e1e2f7fc7a572f9d0316ee60cde7ef025d59b897d29a6fee721aeb2f7bb44f9afb471e8a7b0b43a39b5497a3b4d6beb4b511f0cefa12ce5e6d843609d3e06999acfbee50a22ca1eee" );
23923  iv_len = unhexify( iv_str, "164058e5e425f9da40d22c9098a16204" );
23924  add_len = unhexify( add_str, "6633eae08a1df85f2d36e162f2d7ddd92b0c56b7477f3c6cdb9919d0e4b1e54ea7635c202dcf52d1c688afbbb15552adda32b4cd30aa462b367f02ded02e0d64eeee2a6b95462b191784143c25607fd08a23a2fbc75cf6bee294daf2042587fdd8fe3d22c3a242c624cf0a51a7c14db4f0f766ec437de4c83b64f23706a24437" );
23925  unhexify( tag_str, "2eb6eb6d516ed4cf1778b4e378" );
23926 
23927  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23928  if( 0 == 0 )
23929  {
23930  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23931 
23932  if( strcmp( "FAIL", "FAIL" ) == 0 )
23933  {
23934  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23935  }
23936  else
23937  {
23938  hexify( dst_str, output, pt_len );
23939 
23940  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
23941  }
23942  }
23943  }
23944  FCT_TEST_END();
23945 
23946 
23947  FCT_TEST_BGN(gcm_nist_validation_aes_25612810241024104_2)
23948  {
23949  unsigned char key_str[128];
23950  unsigned char src_str[128];
23951  unsigned char dst_str[257];
23952  unsigned char iv_str[128];
23953  unsigned char add_str[128];
23954  unsigned char tag_str[128];
23955  unsigned char output[128];
23956  gcm_context ctx;
23957  unsigned int key_len;
23958  size_t pt_len, iv_len, add_len, tag_len = 104 / 8;
23959  int ret;
23960 
23961  memset(key_str, 0x00, 128);
23962  memset(src_str, 0x00, 128);
23963  memset(dst_str, 0x00, 257);
23964  memset(iv_str, 0x00, 128);
23965  memset(add_str, 0x00, 128);
23966  memset(tag_str, 0x00, 128);
23967  memset(output, 0x00, 128);
23968 
23969  key_len = unhexify( key_str, "0f9e806b0d937268561c0eafbbdd14ec715b7e9cef4118d6eb28abbb91266745" );
23970  pt_len = unhexify( src_str, "2ae4baef22ace26f464a9b0c75802303f2d7c0f9a1ed1d0180135189765bdd347fea0cc2b73ee7fbbf95ea1fda22597b8aad826f63e744069a9c349488b2cc1cf9372f423cc650302082125724730ae5a4d878e07385ddc99034c6b6b46748f02c80b179fe6406b1d33581950cb9bcd1d1ea1ec7b5becfd6c1f5b279412c433a" );
23971  iv_len = unhexify( iv_str, "8657996634e74d4689f292645f103a2e" );
23972  add_len = unhexify( add_str, "2ca253355e893e58cb1a900fbb62d61595de5c4186dc8a9129da3657a92b4a631bbdc3d5f86395385a9aa8557b67f886e3bb807620e558c93aea8e65826eadeb21544418ee40f5420c2d2b8270491be6fc2dcbfd12847fa350910dd615e9a1881bc2ced3b0ac3bde445b735e43c0c84f9d120ca5edd655779fc13c6f88b484f7" );
23973  unhexify( tag_str, "83155ebb1a42112dd1c474f37b" );
23974 
23975  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
23976  if( 0 == 0 )
23977  {
23978  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
23979 
23980  if( strcmp( "FAIL", "87d69fc3cbc757b2b57b180c6ba34db4e20dde19976bfb3d274d32e7cea13f0c7d9e840d59ce857718c985763b7639e448516ddbbda559457cd8cb364fa99addd5ba44ef45c11060d9be82b4ebe1f0711ac95433074649b6c08eeab539fdfc99c77498b420427e4d70e316111845793de1f67fb0d04e3389a8862f46f4582dc8" ) == 0 )
23981  {
23982  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
23983  }
23984  else
23985  {
23986  hexify( dst_str, output, pt_len );
23987 
23988  fct_chk( strcmp( (char *) dst_str, "87d69fc3cbc757b2b57b180c6ba34db4e20dde19976bfb3d274d32e7cea13f0c7d9e840d59ce857718c985763b7639e448516ddbbda559457cd8cb364fa99addd5ba44ef45c11060d9be82b4ebe1f0711ac95433074649b6c08eeab539fdfc99c77498b420427e4d70e316111845793de1f67fb0d04e3389a8862f46f4582dc8" ) == 0 );
23989  }
23990  }
23991  }
23992  FCT_TEST_END();
23993 
23994 
23995  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102496_0)
23996  {
23997  unsigned char key_str[128];
23998  unsigned char src_str[128];
23999  unsigned char dst_str[257];
24000  unsigned char iv_str[128];
24001  unsigned char add_str[128];
24002  unsigned char tag_str[128];
24003  unsigned char output[128];
24004  gcm_context ctx;
24005  unsigned int key_len;
24006  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
24007  int ret;
24008 
24009  memset(key_str, 0x00, 128);
24010  memset(src_str, 0x00, 128);
24011  memset(dst_str, 0x00, 257);
24012  memset(iv_str, 0x00, 128);
24013  memset(add_str, 0x00, 128);
24014  memset(tag_str, 0x00, 128);
24015  memset(output, 0x00, 128);
24016 
24017  key_len = unhexify( key_str, "c24c17911f6db4b3e37c46bcc6fa35efc1a55f7754f0bb99f2eea93398116447" );
24018  pt_len = unhexify( src_str, "0bd92cb106867e25ad427ff6e5f384d2d0f432fc389852187fcc7b0bf9f6d11a102a872b99ed1ad9a05dab0f79fa634745535efed804ff42b0af8dad20ba44709391fb263f245e5a2c52d9ce904179633282f57a1229b0a9c4557a5c0aeda29bbc5a7a871fa8b62d58100c3722c21e51e3b3e913185235526e7a5a91c559717d" );
24019  iv_len = unhexify( iv_str, "5098cc52a69ee044197e2c000c2d4ab8" );
24020  add_len = unhexify( add_str, "9ad4dee311d854925fc7f10eca4f5dd4e6990cb2d4325da2ef25a9a23690f5c5590be285d33aaeba76506c59edec64b8c3ff8e62716d1c385fbce2a42bc7bd5d8e8584de1944543ab6f340c20911f8b7b3be1a1db18a4bb94119333339de95815cae09365b016edc184e11f3c5b851f1fa92b1b63cfa3872a127109c1294b677" );
24021  unhexify( tag_str, "f7930e3fab74a91cb6543e72" );
24022 
24023  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
24024  if( 0 == 0 )
24025  {
24026  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
24027 
24028  if( strcmp( "FAIL", "6124ede608d416baa5e653a898ca76e9f47f08403c1984feec112e670ded2226e0073f8881ab2161cfda541dccae19691285f7391a729f07aba18f340bb452c1da39cbe83cf476cfc105b64187e0d2227dd283dcba8b6a350f9956b18861fa131d3f00c034443e8f60e0fdfcfaabbed93381ae374a8bf66523d33646183e1379" ) == 0 )
24029  {
24030  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
24031  }
24032  else
24033  {
24034  hexify( dst_str, output, pt_len );
24035 
24036  fct_chk( strcmp( (char *) dst_str, "6124ede608d416baa5e653a898ca76e9f47f08403c1984feec112e670ded2226e0073f8881ab2161cfda541dccae19691285f7391a729f07aba18f340bb452c1da39cbe83cf476cfc105b64187e0d2227dd283dcba8b6a350f9956b18861fa131d3f00c034443e8f60e0fdfcfaabbed93381ae374a8bf66523d33646183e1379" ) == 0 );
24037  }
24038  }
24039  }
24040  FCT_TEST_END();
24041 
24042 
24043  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102496_1)
24044  {
24045  unsigned char key_str[128];
24046  unsigned char src_str[128];
24047  unsigned char dst_str[257];
24048  unsigned char iv_str[128];
24049  unsigned char add_str[128];
24050  unsigned char tag_str[128];
24051  unsigned char output[128];
24052  gcm_context ctx;
24053  unsigned int key_len;
24054  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
24055  int ret;
24056 
24057  memset(key_str, 0x00, 128);
24058  memset(src_str, 0x00, 128);
24059  memset(dst_str, 0x00, 257);
24060  memset(iv_str, 0x00, 128);
24061  memset(add_str, 0x00, 128);
24062  memset(tag_str, 0x00, 128);
24063  memset(output, 0x00, 128);
24064 
24065  key_len = unhexify( key_str, "d267a8379260036ff3d1ec07a7b086ff75706bad12d37d9656f04776f3d8b85c" );
24066  pt_len = unhexify( src_str, "80c68a330ef50e3e516681f1e535868b03466e7edbb86cb385d01db487da3dd3edad940fdc98d918b7db9b59f8d61369eee2928c88557306c4a13e366af0708d94cb90a15f1c3bc45544bdb05ff964da5e06c5ae965f20adb504620aed7bce2e82f4e408d00219c15ef85fae1ff13fea53deb78afa5f2a50edbd622446e4a894" );
24067  iv_len = unhexify( iv_str, "674dc34e8c74c51fa42aacd625a1bd5b" );
24068  add_len = unhexify( add_str, "6a9a8af732ae96d0b5a9730ad792e296150d59770a20a3fdbbc2a3a035a88ac445d64f37d684e22003c214b771c1995719da72f3ed24a96618284dd414f0cac364640b23c680dc80492a435c8ec10add53b0d9e3374f1cf5bfc663e3528fa2f6209846421ea6f481b7ecf57714f7bc2527edc4e0466b13e750dd4d4c0cc0cdfc" );
24069  unhexify( tag_str, "bea660e963b08fc657741bc8" );
24070 
24071  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
24072  if( 0 == 0 )
24073  {
24074  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
24075 
24076  if( strcmp( "FAIL", "FAIL" ) == 0 )
24077  {
24078  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
24079  }
24080  else
24081  {
24082  hexify( dst_str, output, pt_len );
24083 
24084  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
24085  }
24086  }
24087  }
24088  FCT_TEST_END();
24089 
24090 
24091  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102496_2)
24092  {
24093  unsigned char key_str[128];
24094  unsigned char src_str[128];
24095  unsigned char dst_str[257];
24096  unsigned char iv_str[128];
24097  unsigned char add_str[128];
24098  unsigned char tag_str[128];
24099  unsigned char output[128];
24100  gcm_context ctx;
24101  unsigned int key_len;
24102  size_t pt_len, iv_len, add_len, tag_len = 96 / 8;
24103  int ret;
24104 
24105  memset(key_str, 0x00, 128);
24106  memset(src_str, 0x00, 128);
24107  memset(dst_str, 0x00, 257);
24108  memset(iv_str, 0x00, 128);
24109  memset(add_str, 0x00, 128);
24110  memset(tag_str, 0x00, 128);
24111  memset(output, 0x00, 128);
24112 
24113  key_len = unhexify( key_str, "c86cb637753010f639fa3aa3bff7c28b74f012ad6090f2a31b0801d086f183ad" );
24114  pt_len = unhexify( src_str, "6b7858557e0fd0f957842fb30e8d54dedbc127eb4bbf9de319f731fa28a606df2c046a0bce8ecda4e75d3596e4e988efd6bc279aa005bc52fad92ba07f5b1dfda4cc417029f9778c88d6fe5341a0fd48893dcb7c68d0df310a060f2a5235aee422d380f7209bc0909b2aa7e876044056f0b915dab0bc13cbea5a3b86d40ca802" );
24115  iv_len = unhexify( iv_str, "87ff6e0bb313502fedf3d2696bff99b5" );
24116  add_len = unhexify( add_str, "2816f1132724f42e40deabab25e325b282f8c615a79e0c98c00d488ee56237537240234966565e46bfb0c50f2b10366d1589620e6e78bd90ade24d38a272f3fff53c09466aa2d3ef793d7f814a064b713821850a6e6a058f5139a1088347a9fa0f54e38abd51ddfc7ef040bf41d188f3f86c973551ced019812c1fc668649621" );
24117  unhexify( tag_str, "7859f047f32b51833333accf" );
24118 
24119  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
24120  if( 0 == 0 )
24121  {
24122  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
24123 
24124  if( strcmp( "FAIL", "FAIL" ) == 0 )
24125  {
24126  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
24127  }
24128  else
24129  {
24130  hexify( dst_str, output, pt_len );
24131 
24132  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
24133  }
24134  }
24135  }
24136  FCT_TEST_END();
24137 
24138 
24139  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102464_0)
24140  {
24141  unsigned char key_str[128];
24142  unsigned char src_str[128];
24143  unsigned char dst_str[257];
24144  unsigned char iv_str[128];
24145  unsigned char add_str[128];
24146  unsigned char tag_str[128];
24147  unsigned char output[128];
24148  gcm_context ctx;
24149  unsigned int key_len;
24150  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
24151  int ret;
24152 
24153  memset(key_str, 0x00, 128);
24154  memset(src_str, 0x00, 128);
24155  memset(dst_str, 0x00, 257);
24156  memset(iv_str, 0x00, 128);
24157  memset(add_str, 0x00, 128);
24158  memset(tag_str, 0x00, 128);
24159  memset(output, 0x00, 128);
24160 
24161  key_len = unhexify( key_str, "2c31ca0cac3efe467168198f06beacf39565a6f57f82e1048a5c06a231315882" );
24162  pt_len = unhexify( src_str, "65261d6e29b2369b1828a7cef2df9873d6e6057c499301afedd6cb65b5036ddb95f9e353fbf38e54c4f46f88164325b33620ce183beb2e411fbb89a0e0002e542fc161cad32a61ee6f1e1717e0b4dcd0340b116f795bc1009dbbc65bc31c9b549bf03c40bc204cd0d02ec884be907777ebeed8b527ec3af7cbb508193c0745de" );
24163  iv_len = unhexify( iv_str, "95cae6e85f33f3043182460589be3639" );
24164  add_len = unhexify( add_str, "67523751a9b1b643d00de4511b55e4268cb2d18e79e01a55fc7b677d529bd6400940fb25ea6ae135c1a816e61b69e90b966981aeda685934b107066e1467db78973492ad791e20aef430db3a047447141def8be6e6a9a15089607c3af9368cdb11b7b5fbf90691505d0c33664766945d387904e7089b915a3c28886ba1763bb5" );
24165  unhexify( tag_str, "21309d0351cac45e" );
24166 
24167  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
24168  if( 0 == 0 )
24169  {
24170  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
24171 
24172  if( strcmp( "FAIL", "1d5f2cb921f54aeb552b4304142facd49497837deb1f00d26fbeddbab922fd80b00dba782961f8fce84f1f7973e81eed6ee168b1760c575c891f40a1dae0fa1a08738025d13ef6e0b30be4f054d874f1b8a2427a19ebb071d98365c32316a88a68c2b40daf1ea831a64519ac3679acb4e04986ecc614ec673c498c6fee459e40" ) == 0 )
24173  {
24174  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
24175  }
24176  else
24177  {
24178  hexify( dst_str, output, pt_len );
24179 
24180  fct_chk( strcmp( (char *) dst_str, "1d5f2cb921f54aeb552b4304142facd49497837deb1f00d26fbeddbab922fd80b00dba782961f8fce84f1f7973e81eed6ee168b1760c575c891f40a1dae0fa1a08738025d13ef6e0b30be4f054d874f1b8a2427a19ebb071d98365c32316a88a68c2b40daf1ea831a64519ac3679acb4e04986ecc614ec673c498c6fee459e40" ) == 0 );
24181  }
24182  }
24183  }
24184  FCT_TEST_END();
24185 
24186 
24187  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102464_1)
24188  {
24189  unsigned char key_str[128];
24190  unsigned char src_str[128];
24191  unsigned char dst_str[257];
24192  unsigned char iv_str[128];
24193  unsigned char add_str[128];
24194  unsigned char tag_str[128];
24195  unsigned char output[128];
24196  gcm_context ctx;
24197  unsigned int key_len;
24198  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
24199  int ret;
24200 
24201  memset(key_str, 0x00, 128);
24202  memset(src_str, 0x00, 128);
24203  memset(dst_str, 0x00, 257);
24204  memset(iv_str, 0x00, 128);
24205  memset(add_str, 0x00, 128);
24206  memset(tag_str, 0x00, 128);
24207  memset(output, 0x00, 128);
24208 
24209  key_len = unhexify( key_str, "ca9fa36ca2159dff9723f6cfdb13280446eb6bc3688043c7e2e2504184791596" );
24210  pt_len = unhexify( src_str, "ac04c4293554cd832aa400c811cb202d815d6178aa1343b4628592b7f3ae45dc5f12ea47be4b43e1865f40b06ab67b3a9fb3644248a9b3efe131a8addb7447978bb51ccf749e75574fea60e8781677200af023b2f8c415f4e6d8c575a9e374916d9ec3a612b16e37beb589444b588e0b770d9f8e818ad83f83aa4ecf386d17a7" );
24211  iv_len = unhexify( iv_str, "d13ca73365e57114fc698ee60ba0ad84" );
24212  add_len = unhexify( add_str, "2aa510b7f1620bfce90080e0e25f5468dbc5314b50914e793b5278369c51ac017eace9fd15127fca5a726ad9e67bdee5af298988d9a57ec4bbc43d4eb849535eb10521ac7cd7ed647479a42876af2ebc9e2108b539febdaa9127c49bda1bda800f6034050b8576e944311dfbca59d64d259571b6d2ed5b2fc07127239b03f4b7" );
24213  unhexify( tag_str, "2111d55d96a4d84d" );
24214 
24215  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
24216  if( 0 == 0 )
24217  {
24218  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
24219 
24220  if( strcmp( "FAIL", "FAIL" ) == 0 )
24221  {
24222  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
24223  }
24224  else
24225  {
24226  hexify( dst_str, output, pt_len );
24227 
24228  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
24229  }
24230  }
24231  }
24232  FCT_TEST_END();
24233 
24234 
24235  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102464_2)
24236  {
24237  unsigned char key_str[128];
24238  unsigned char src_str[128];
24239  unsigned char dst_str[257];
24240  unsigned char iv_str[128];
24241  unsigned char add_str[128];
24242  unsigned char tag_str[128];
24243  unsigned char output[128];
24244  gcm_context ctx;
24245  unsigned int key_len;
24246  size_t pt_len, iv_len, add_len, tag_len = 64 / 8;
24247  int ret;
24248 
24249  memset(key_str, 0x00, 128);
24250  memset(src_str, 0x00, 128);
24251  memset(dst_str, 0x00, 257);
24252  memset(iv_str, 0x00, 128);
24253  memset(add_str, 0x00, 128);
24254  memset(tag_str, 0x00, 128);
24255  memset(output, 0x00, 128);
24256 
24257  key_len = unhexify( key_str, "2f802e838250064c15fdee28d7bd4872850355870847701ad9742b2d6eb4b0c0" );
24258  pt_len = unhexify( src_str, "e2ca8c8d172ff90232879f510d1225af91bc323bdf636363c2903fcd1790692c8bcb03a1cccb18814678852c6b3a441552e541b843ee5e4f86a152fa73d05aea659fe08aa6428bb257eaa2a7b579fdc4022c1dec359a854253c1aefc983c5ede8c97517ea69fc4606e25f13ffb0f5f49160691454fbb74e704326738353525f7" );
24259  iv_len = unhexify( iv_str, "2dd550cfd97f8e1d8d31ba5537ae4710" );
24260  add_len = unhexify( add_str, "72b9630dda40306e785b961934c56e20948f8eac0e981f49787eb3dbd6e4607f7d08d10ca643746bf1efa7e5066993683d527a90f2d45ec9cf73113f1f17bb67958be669acd4e2927f1dacfde902cd3048056d7f6dfdd8630ff054efce4526db7c9321d6d2be2236f4d60e27b89d8ec94f65a06dc0953c8c4533a51b6a29bd2c" );
24261  unhexify( tag_str, "bd6c8823c9005c85" );
24262 
24263  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
24264  if( 0 == 0 )
24265  {
24266  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
24267 
24268  if( strcmp( "FAIL", "f6dd0b5f3d1a393a1837112962dba175a13c2d1e525ef95734caf34949d8b2d63b4fe5603226b5f632f2d7f927361ba639dc0e3c63414f45462342695916d5792133b4a24c7c4cbe2b97c712bf27ab62d3d68b3875d58ffe4b7c30a8171bff1a9e2f3995768faacda2ea9213ff35798b9e4513f6a87bd3f5a9d93e847e768359" ) == 0 )
24269  {
24270  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
24271  }
24272  else
24273  {
24274  hexify( dst_str, output, pt_len );
24275 
24276  fct_chk( strcmp( (char *) dst_str, "f6dd0b5f3d1a393a1837112962dba175a13c2d1e525ef95734caf34949d8b2d63b4fe5603226b5f632f2d7f927361ba639dc0e3c63414f45462342695916d5792133b4a24c7c4cbe2b97c712bf27ab62d3d68b3875d58ffe4b7c30a8171bff1a9e2f3995768faacda2ea9213ff35798b9e4513f6a87bd3f5a9d93e847e768359" ) == 0 );
24277  }
24278  }
24279  }
24280  FCT_TEST_END();
24281 
24282 
24283  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102432_0)
24284  {
24285  unsigned char key_str[128];
24286  unsigned char src_str[128];
24287  unsigned char dst_str[257];
24288  unsigned char iv_str[128];
24289  unsigned char add_str[128];
24290  unsigned char tag_str[128];
24291  unsigned char output[128];
24292  gcm_context ctx;
24293  unsigned int key_len;
24294  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
24295  int ret;
24296 
24297  memset(key_str, 0x00, 128);
24298  memset(src_str, 0x00, 128);
24299  memset(dst_str, 0x00, 257);
24300  memset(iv_str, 0x00, 128);
24301  memset(add_str, 0x00, 128);
24302  memset(tag_str, 0x00, 128);
24303  memset(output, 0x00, 128);
24304 
24305  key_len = unhexify( key_str, "84dd53ce0146cb71c32776033bb243098d78a22ac17f52a62a122f5653fb4e33" );
24306  pt_len = unhexify( src_str, "68222bffa782dcfe4f328fc20eb520e75a9a5fedbe13ec7fcf0e82fba08bb87a8a8e02902638e32fe0e2294344b380797f8028426ffcc0531c739c884892394c48ff0779c5f5edf0a36a3fb8aa91213347774ec4bf0fe1049bd53746b13beef3c637169826c367056cb1aa0a3868e23f886a9c7b8015c26af9e40794662f6b21" );
24307  iv_len = unhexify( iv_str, "f0c90a1bca52f30fab3670df0d3beab0" );
24308  add_len = unhexify( add_str, "a3ea8032f36a5ca3d7a1088fd08ac50ae6bdc06ad3a534b773ac3e3d4a3d524499e56274a0062c58c3b0685cc850f4725e5c221af8f51c6df2bbd5fbcff4a93ba4c1054f7f9c67fd9285511a08d328d76a642f067227d378f95a1e67587b90251f9103ed3cacdb6bf69e0794e366d8b92d8de37b4e028de0778841f356ac044d" );
24309  unhexify( tag_str, "b1ece9fb" );
24310 
24311  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
24312  if( 0 == 0 )
24313  {
24314  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
24315 
24316  if( strcmp( "FAIL", "FAIL" ) == 0 )
24317  {
24318  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
24319  }
24320  else
24321  {
24322  hexify( dst_str, output, pt_len );
24323 
24324  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
24325  }
24326  }
24327  }
24328  FCT_TEST_END();
24329 
24330 
24331  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102432_1)
24332  {
24333  unsigned char key_str[128];
24334  unsigned char src_str[128];
24335  unsigned char dst_str[257];
24336  unsigned char iv_str[128];
24337  unsigned char add_str[128];
24338  unsigned char tag_str[128];
24339  unsigned char output[128];
24340  gcm_context ctx;
24341  unsigned int key_len;
24342  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
24343  int ret;
24344 
24345  memset(key_str, 0x00, 128);
24346  memset(src_str, 0x00, 128);
24347  memset(dst_str, 0x00, 257);
24348  memset(iv_str, 0x00, 128);
24349  memset(add_str, 0x00, 128);
24350  memset(tag_str, 0x00, 128);
24351  memset(output, 0x00, 128);
24352 
24353  key_len = unhexify( key_str, "9bb36fe25e966a075ae2c3bb43b5877679ebc379d5123c8eda3fa0e30b95cae0" );
24354  pt_len = unhexify( src_str, "fb3a4be643c10343251c6f0745aaa54349463f622ca04a792e9b4780866844b30aeef3269fc60cac0ea031c5f3780b535e15154f7c76eb4a371b8ae368550f3fa2ce693c34511ec96b839cac567f1b0de0e7e3116d729b45d1b16e453703a43db73f5d0c3e430f16b142420b5f0d26d72ac3dba543d7d813603b0bfdca3dd63e" );
24355  iv_len = unhexify( iv_str, "59869df4ef5754b406478a2fb608ee99" );
24356  add_len = unhexify( add_str, "ecd125682e8a8e26757c888b0c8b95dec5e7ed7ac991768f93e8af5bcf6f21ed4d4d38699ee7984ed13635fff72f938150157c9a27fcda121ffced7b492d2b18dad299cb6495ed5f68441aefc8219d2cf717d15d5cd2dbce4606fcf90fe45f3601127cf6acee210bd7df97309f773974a35bef1d33df984101c2fc9d4b55259e" );
24357  unhexify( tag_str, "cb3f5338" );
24358 
24359  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
24360  if( 0 == 0 )
24361  {
24362  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
24363 
24364  if( strcmp( "FAIL", "FAIL" ) == 0 )
24365  {
24366  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
24367  }
24368  else
24369  {
24370  hexify( dst_str, output, pt_len );
24371 
24372  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
24373  }
24374  }
24375  }
24376  FCT_TEST_END();
24377 
24378 
24379  FCT_TEST_BGN(gcm_nist_validation_aes_2561281024102432_2)
24380  {
24381  unsigned char key_str[128];
24382  unsigned char src_str[128];
24383  unsigned char dst_str[257];
24384  unsigned char iv_str[128];
24385  unsigned char add_str[128];
24386  unsigned char tag_str[128];
24387  unsigned char output[128];
24388  gcm_context ctx;
24389  unsigned int key_len;
24390  size_t pt_len, iv_len, add_len, tag_len = 32 / 8;
24391  int ret;
24392 
24393  memset(key_str, 0x00, 128);
24394  memset(src_str, 0x00, 128);
24395  memset(dst_str, 0x00, 257);
24396  memset(iv_str, 0x00, 128);
24397  memset(add_str, 0x00, 128);
24398  memset(tag_str, 0x00, 128);
24399  memset(output, 0x00, 128);
24400 
24401  key_len = unhexify( key_str, "ca264e7caecad56ee31c8bf8dde9592f753a6299e76c60ac1e93cff3b3de8ce9" );
24402  pt_len = unhexify( src_str, "8d03cf6fac31182ad3e6f32e4c823e3b421aef786d5651afafbf70ef14c00524ab814bc421b1d4181b4d3d82d6ae4e8032e43a6c4e0691184425b37320798f865c88b9b306466311d79e3e42076837474c37c9f6336ed777f05f70b0c7d72bd4348a4cd754d0f0c3e4587f9a18313ea2d2bace502a24ea417d3041b709a0471f" );
24403  iv_len = unhexify( iv_str, "4763a4e37b806a5f4510f69fd8c63571" );
24404  add_len = unhexify( add_str, "07daeba37a66ebe15f3d6451d1176f3a7107a302da6966680c425377e621fd71610d1fc9c95122da5bf85f83b24c4b783b1dcd6b508d41e22c09b5c43693d072869601fc7e3f5a51dbd3bc6508e8d095b9130fb6a7f2a043f3a432e7ce68b7de06c1379e6bab5a1a48823b76762051b4e707ddc3201eb36456e3862425cb011a" );
24405  unhexify( tag_str, "3105dddb" );
24406 
24407  fct_chk( gcm_init( &ctx, key_str, key_len * 8 ) == 0 );
24408  if( 0 == 0 )
24409  {
24410  ret = gcm_auth_decrypt( &ctx, pt_len, iv_str, iv_len, add_str, add_len, tag_str, tag_len, src_str, output );
24411 
24412  if( strcmp( "FAIL", "FAIL" ) == 0 )
24413  {
24414  fct_chk( ret == POLARSSL_ERR_GCM_AUTH_FAILED );
24415  }
24416  else
24417  {
24418  hexify( dst_str, output, pt_len );
24419 
24420  fct_chk( strcmp( (char *) dst_str, "FAIL" ) == 0 );
24421  }
24422  }
24423  }
24424  FCT_TEST_END();
24425 
24426  }
24427  FCT_SUITE_END();
24428 
24429 #endif /* POLARSSL_GCM_C */
24430 
24431 }
24432 FCT_END();
24433