PolarSSL v1.3.8
test_suite_x509parse.c
Go to the documentation of this file.
1 #if !defined(POLARSSL_CONFIG_FILE)
2 #include <polarssl/config.h>
3 #else
4 #include POLARSSL_CONFIG_FILE
5 #endif
6 
7 #ifdef POLARSSL_BIGNUM_C
8 
9 #include <polarssl/x509_crt.h>
10 #include <polarssl/x509_crl.h>
11 #include <polarssl/x509_csr.h>
12 #include <polarssl/pem.h>
13 #include <polarssl/oid.h>
14 
15 int verify_none( void *data, x509_crt *crt, int certificate_depth, int *flags )
16 {
17  ((void) data);
18  ((void) crt);
19  ((void) certificate_depth);
20  *flags |= BADCERT_OTHER;
21 
22  return 0;
23 }
24 
25 int verify_all( void *data, x509_crt *crt, int certificate_depth, int *flags )
26 {
27  ((void) data);
28  ((void) crt);
29  ((void) certificate_depth);
30  *flags = 0;
31 
32  return 0;
33 }
34 
35 #endif /* POLARSSL_BIGNUM_C */
36 
37 
38 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
39 #include "polarssl/memory.h"
40 #endif
41 
42 #if defined(POLARSSL_PLATFORM_C)
43 #include "polarssl/platform.h"
44 #else
45 #define polarssl_malloc malloc
46 #define polarssl_free free
47 #endif
48 
49 #ifdef _MSC_VER
50 #include <basetsd.h>
51 typedef UINT32 uint32_t;
52 #else
53 #include <inttypes.h>
54 #endif
55 
56 #include <assert.h>
57 #include <stdlib.h>
58 #include <string.h>
59 
60 /*
61  * 32-bit integer manipulation macros (big endian)
62  */
63 #ifndef GET_UINT32_BE
64 #define GET_UINT32_BE(n,b,i) \
65 { \
66  (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
67  | ( (uint32_t) (b)[(i) + 1] << 16 ) \
68  | ( (uint32_t) (b)[(i) + 2] << 8 ) \
69  | ( (uint32_t) (b)[(i) + 3] ); \
70 }
71 #endif
72 
73 #ifndef PUT_UINT32_BE
74 #define PUT_UINT32_BE(n,b,i) \
75 { \
76  (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
77  (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
78  (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
79  (b)[(i) + 3] = (unsigned char) ( (n) ); \
80 }
81 #endif
82 
83 static int unhexify(unsigned char *obuf, const char *ibuf)
84 {
85  unsigned char c, c2;
86  int len = strlen(ibuf) / 2;
87  assert(!(strlen(ibuf) %1)); // must be even number of bytes
88 
89  while (*ibuf != 0)
90  {
91  c = *ibuf++;
92  if( c >= '0' && c <= '9' )
93  c -= '0';
94  else if( c >= 'a' && c <= 'f' )
95  c -= 'a' - 10;
96  else if( c >= 'A' && c <= 'F' )
97  c -= 'A' - 10;
98  else
99  assert( 0 );
100 
101  c2 = *ibuf++;
102  if( c2 >= '0' && c2 <= '9' )
103  c2 -= '0';
104  else if( c2 >= 'a' && c2 <= 'f' )
105  c2 -= 'a' - 10;
106  else if( c2 >= 'A' && c2 <= 'F' )
107  c2 -= 'A' - 10;
108  else
109  assert( 0 );
110 
111  *obuf++ = ( c << 4 ) | c2;
112  }
113 
114  return len;
115 }
116 
117 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
118 {
119  unsigned char l, h;
120 
121  while (len != 0)
122  {
123  h = (*ibuf) / 16;
124  l = (*ibuf) % 16;
125 
126  if( h < 10 )
127  *obuf++ = '0' + h;
128  else
129  *obuf++ = 'a' + h - 10;
130 
131  if( l < 10 )
132  *obuf++ = '0' + l;
133  else
134  *obuf++ = 'a' + l - 10;
135 
136  ++ibuf;
137  len--;
138  }
139 }
140 
148 static unsigned char *zero_alloc( size_t len )
149 {
150  void *p;
151  size_t actual_len = len != 0 ? len : 1;
152 
153  p = polarssl_malloc( actual_len );
154  assert( p != NULL );
155 
156  memset( p, 0x00, actual_len );
157 
158  return( p );
159 }
160 
171 static unsigned char *unhexify_alloc( const char *ibuf, size_t *olen )
172 {
173  unsigned char *obuf;
174 
175  *olen = strlen(ibuf) / 2;
176 
177  if( *olen == 0 )
178  return( zero_alloc( *olen ) );
179 
180  obuf = polarssl_malloc( *olen );
181  assert( obuf != NULL );
182 
183  (void) unhexify( obuf, ibuf );
184 
185  return( obuf );
186 }
187 
197 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
198 {
199 #if !defined(__OpenBSD__)
200  size_t i;
201 
202  if( rng_state != NULL )
203  rng_state = NULL;
204 
205  for( i = 0; i < len; ++i )
206  output[i] = rand();
207 #else
208  if( rng_state != NULL )
209  rng_state = NULL;
210 
211  arc4random_buf( output, len );
212 #endif /* !OpenBSD */
213 
214  return( 0 );
215 }
216 
222 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
223 {
224  if( rng_state != NULL )
225  rng_state = NULL;
226 
227  memset( output, 0, len );
228 
229  return( 0 );
230 }
231 
232 typedef struct
233 {
234  unsigned char *buf;
235  size_t length;
236 } rnd_buf_info;
237 
249 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
250 {
251  rnd_buf_info *info = (rnd_buf_info *) rng_state;
252  size_t use_len;
253 
254  if( rng_state == NULL )
255  return( rnd_std_rand( NULL, output, len ) );
256 
257  use_len = len;
258  if( len > info->length )
259  use_len = info->length;
260 
261  if( use_len )
262  {
263  memcpy( output, info->buf, use_len );
264  info->buf += use_len;
265  info->length -= use_len;
266  }
267 
268  if( len - use_len > 0 )
269  return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
270 
271  return( 0 );
272 }
273 
281 typedef struct
282 {
283  uint32_t key[16];
284  uint32_t v0, v1;
286 
295 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
296 {
297  rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
298  uint32_t i, *k, sum, delta=0x9E3779B9;
299  unsigned char result[4], *out = output;
300 
301  if( rng_state == NULL )
302  return( rnd_std_rand( NULL, output, len ) );
303 
304  k = info->key;
305 
306  while( len > 0 )
307  {
308  size_t use_len = ( len > 4 ) ? 4 : len;
309  sum = 0;
310 
311  for( i = 0; i < 32; i++ )
312  {
313  info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
314  sum += delta;
315  info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
316  }
317 
318  PUT_UINT32_BE( info->v0, result, 0 );
319  memcpy( out, result, use_len );
320  len -= use_len;
321  out += 4;
322  }
323 
324  return( 0 );
325 }
326 
327 
328 #include <stdio.h>
329 #include <string.h>
330 
331 #if defined(POLARSSL_PLATFORM_C)
332 #include "polarssl/platform.h"
333 #else
334 #define polarssl_printf printf
335 #define polarssl_malloc malloc
336 #define polarssl_free free
337 #endif
338 
339 static int test_errors = 0;
340 
341 #ifdef POLARSSL_BIGNUM_C
342 
343 #define TEST_SUITE_ACTIVE
344 
345 static int test_assert( int correct, const char *test )
346 {
347  if( correct )
348  return( 0 );
349 
350  test_errors++;
351  if( test_errors == 1 )
352  printf( "FAILED\n" );
353  printf( " %s\n", test );
354 
355  return( 1 );
356 }
357 
358 #define TEST_ASSERT( TEST ) \
359  do { test_assert( (TEST) ? 1 : 0, #TEST ); \
360  if( test_errors) goto exit; \
361  } while (0)
362 
363 int verify_string( char **str )
364 {
365  if( (*str)[0] != '"' ||
366  (*str)[strlen( *str ) - 1] != '"' )
367  {
368  printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
369  return( -1 );
370  }
371 
372  (*str)++;
373  (*str)[strlen( *str ) - 1] = '\0';
374 
375  return( 0 );
376 }
377 
378 int verify_int( char *str, int *value )
379 {
380  size_t i;
381  int minus = 0;
382  int digits = 1;
383  int hex = 0;
384 
385  for( i = 0; i < strlen( str ); i++ )
386  {
387  if( i == 0 && str[i] == '-' )
388  {
389  minus = 1;
390  continue;
391  }
392 
393  if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
394  str[i - 1] == '0' && str[i] == 'x' )
395  {
396  hex = 1;
397  continue;
398  }
399 
400  if( ! ( ( str[i] >= '0' && str[i] <= '9' ) ||
401  ( hex && ( ( str[i] >= 'a' && str[i] <= 'f' ) ||
402  ( str[i] >= 'A' && str[i] <= 'F' ) ) ) ) )
403  {
404  digits = 0;
405  break;
406  }
407  }
408 
409  if( digits )
410  {
411  if( hex )
412  *value = strtol( str, NULL, 16 );
413  else
414  *value = strtol( str, NULL, 10 );
415 
416  return( 0 );
417  }
418 
419 #ifdef POLARSSL_FS_IO
420 #ifdef POLARSSL_X509_CRT_PARSE_C
421 #ifdef POLARSSL_X509_CRL_PARSE_C
422  if( strcmp( str, "POLARSSL_ERR_X509_CERT_VERIFY_FAILED" ) == 0 )
423  {
425  return( 0 );
426  }
427 #endif // POLARSSL_FS_IO
428 #endif // POLARSSL_X509_CRT_PARSE_C
429 #endif // POLARSSL_X509_CRL_PARSE_C
430 #ifdef POLARSSL_X509_CSR_PARSE_C
431  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_NAME + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
432  {
434  return( 0 );
435  }
436 #endif // POLARSSL_X509_CSR_PARSE_C
437 #ifdef POLARSSL_X509_CRT_PARSE_C
438  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_NAME + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
439  {
441  return( 0 );
442  }
443 #endif // POLARSSL_X509_CRT_PARSE_C
444 #ifdef POLARSSL_X509_CRT_PARSE_C
445 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
446  if( strcmp( str, "ASN1_SEQUENCE" ) == 0 )
447  {
448  *value = ( ASN1_SEQUENCE );
449  return( 0 );
450  }
451 #endif // POLARSSL_X509_CRT_PARSE_C
452 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
453 #ifdef POLARSSL_X509_CRT_PARSE_C
454  if( strcmp( str, "POLARSSL_ERR_ASN1_INVALID_LENGTH" ) == 0 )
455  {
457  return( 0 );
458  }
459 #endif // POLARSSL_X509_CRT_PARSE_C
460 #ifdef POLARSSL_FS_IO
461 #ifdef POLARSSL_X509_CRT_PARSE_C
462 #ifdef POLARSSL_X509_CRL_PARSE_C
463  if( strcmp( str, "BADCERT_REVOKED | BADCERT_CN_MISMATCH" ) == 0 )
464  {
465  *value = ( BADCERT_REVOKED | BADCERT_CN_MISMATCH );
466  return( 0 );
467  }
468 #endif // POLARSSL_FS_IO
469 #endif // POLARSSL_X509_CRT_PARSE_C
470 #endif // POLARSSL_X509_CRL_PARSE_C
471 #ifdef POLARSSL_X509_CRL_PARSE_C
472  if( strcmp( str, "POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
473  {
474  *value = ( POLARSSL_ERR_ASN1_OUT_OF_DATA );
475  return( 0 );
476  }
477 #endif // POLARSSL_X509_CRL_PARSE_C
478 #ifdef POLARSSL_X509_CRT_PARSE_C
479  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_SERIAL + POLARSSL_ERR_ASN1_OUT_OF_DATA " ) == 0 )
480  {
482  return( 0 );
483  }
484 #endif // POLARSSL_X509_CRT_PARSE_C
485 #ifdef POLARSSL_FS_IO
486 #ifdef POLARSSL_X509_CRT_PARSE_C
487 #ifdef POLARSSL_X509_CRL_PARSE_C
488  if( strcmp( str, "BADCERT_CN_MISMATCH" ) == 0 )
489  {
490  *value = ( BADCERT_CN_MISMATCH );
491  return( 0 );
492  }
493 #endif // POLARSSL_FS_IO
494 #endif // POLARSSL_X509_CRT_PARSE_C
495 #endif // POLARSSL_X509_CRL_PARSE_C
496 #ifdef POLARSSL_X509_CSR_PARSE_C
497  if( strcmp( str, "POLARSSL_ERR_PK_KEY_INVALID_FORMAT + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
498  {
500  return( 0 );
501  }
502 #endif // POLARSSL_X509_CSR_PARSE_C
503 #ifdef POLARSSL_X509_CSR_PARSE_C
504  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_SIGNATURE + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
505  {
507  return( 0 );
508  }
509 #endif // POLARSSL_X509_CSR_PARSE_C
510 #ifdef POLARSSL_X509_CRT_PARSE_C
511  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_SIGNATURE + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
512  {
514  return( 0 );
515  }
516 #endif // POLARSSL_X509_CRT_PARSE_C
517 #ifdef POLARSSL_X509_CSR_PARSE_C
518  if( strcmp( str, "POLARSSL_ERR_PK_KEY_INVALID_FORMAT + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
519  {
521  return( 0 );
522  }
523 #endif // POLARSSL_X509_CSR_PARSE_C
524 #ifdef POLARSSL_X509_CRT_PARSE_C
525  if( strcmp( str, "POLARSSL_ERR_PK_KEY_INVALID_FORMAT + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
526  {
528  return( 0 );
529  }
530 #endif // POLARSSL_X509_CRT_PARSE_C
531 #ifdef POLARSSL_FS_IO
532 #ifdef POLARSSL_X509_CRT_PARSE_C
533 #ifdef POLARSSL_X509_CRL_PARSE_C
534  if( strcmp( str, "BADCERT_FUTURE" ) == 0 )
535  {
536  *value = ( BADCERT_FUTURE );
537  return( 0 );
538  }
539 #endif // POLARSSL_FS_IO
540 #endif // POLARSSL_X509_CRT_PARSE_C
541 #endif // POLARSSL_X509_CRL_PARSE_C
542 #ifdef POLARSSL_X509_CSR_PARSE_C
543  if( strcmp( str, " 1" ) == 0 )
544  {
545  *value = ( 1 );
546  return( 0 );
547  }
548 #endif // POLARSSL_X509_CSR_PARSE_C
549 #ifdef POLARSSL_X509_CRT_PARSE_C
550  if( strcmp( str, " 1" ) == 0 )
551  {
552  *value = ( 1 );
553  return( 0 );
554  }
555 #endif // POLARSSL_X509_CRT_PARSE_C
556 #ifdef POLARSSL_X509_CRL_PARSE_C
557  if( strcmp( str, " 1" ) == 0 )
558  {
559  *value = ( 1 );
560  return( 0 );
561  }
562 #endif // POLARSSL_X509_CRL_PARSE_C
563 #ifdef POLARSSL_FS_IO
564 #ifdef POLARSSL_X509_CRT_PARSE_C
565 #ifdef POLARSSL_X509_CRL_PARSE_C
566  if( strcmp( str, "BADCRL_EXPIRED" ) == 0 )
567  {
568  *value = ( BADCRL_EXPIRED );
569  return( 0 );
570  }
571 #endif // POLARSSL_FS_IO
572 #endif // POLARSSL_X509_CRT_PARSE_C
573 #endif // POLARSSL_X509_CRL_PARSE_C
574 #ifdef POLARSSL_X509_CRT_PARSE_C
575 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
576  if( strcmp( str, "ASN1_CONSTRUCTED | ASN1_SEQUENCE" ) == 0 )
577  {
578  *value = ( ASN1_CONSTRUCTED | ASN1_SEQUENCE );
579  return( 0 );
580  }
581 #endif // POLARSSL_X509_CRT_PARSE_C
582 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
583 #ifdef POLARSSL_X509_CRT_PARSE_C
584  if( strcmp( str, "POLARSSL_ERR_PK_INVALID_PUBKEY + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
585  {
587  return( 0 );
588  }
589 #endif // POLARSSL_X509_CRT_PARSE_C
590 #ifdef POLARSSL_FS_IO
591 #ifdef POLARSSL_X509_CRT_PARSE_C
592 #ifdef POLARSSL_X509_CRL_PARSE_C
593  if( strcmp( str, "BADCERT_REVOKED | BADCRL_EXPIRED" ) == 0 )
594  {
595  *value = ( BADCERT_REVOKED | BADCRL_EXPIRED );
596  return( 0 );
597  }
598 #endif // POLARSSL_FS_IO
599 #endif // POLARSSL_X509_CRT_PARSE_C
600 #endif // POLARSSL_X509_CRL_PARSE_C
601 #ifdef POLARSSL_X509_CRT_PARSE_C
602 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
603  if( strcmp( str, "POLARSSL_ERR_X509_FEATURE_UNAVAILABLE + POLARSSL_ERR_OID_NOT_FOUND" ) == 0 )
604  {
606  return( 0 );
607  }
608 #endif // POLARSSL_X509_CRT_PARSE_C
609 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
610 #ifdef POLARSSL_FS_IO
611 #ifdef POLARSSL_X509_CRT_PARSE_C
612 #ifdef POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE
613  if( strcmp( str, "POLARSSL_ERR_X509_BAD_INPUT_DATA" ) == 0 )
614  {
616  return( 0 );
617  }
618 #endif // POLARSSL_FS_IO
619 #endif // POLARSSL_X509_CRT_PARSE_C
620 #endif // POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE
621 #ifdef POLARSSL_FS_IO
622 #ifdef POLARSSL_X509_CRT_PARSE_C
623 #ifdef POLARSSL_X509_CHECK_KEY_USAGE
624  if( strcmp( str, "POLARSSL_ERR_X509_BAD_INPUT_DATA" ) == 0 )
625  {
627  return( 0 );
628  }
629 #endif // POLARSSL_FS_IO
630 #endif // POLARSSL_X509_CRT_PARSE_C
631 #endif // POLARSSL_X509_CHECK_KEY_USAGE
632 #ifdef POLARSSL_X509_CRT_PARSE_C
633  if( strcmp( str, "POLARSSL_ERR_PK_INVALID_ALG + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
634  {
636  return( 0 );
637  }
638 #endif // POLARSSL_X509_CRT_PARSE_C
639 #ifdef POLARSSL_X509_CRT_PARSE_C
640  if( strcmp( str, "POLARSSL_ERR_X509_UNKNOWN_SIG_ALG + POLARSSL_ERR_OID_NOT_FOUND" ) == 0 )
641  {
643  return( 0 );
644  }
645 #endif // POLARSSL_X509_CRT_PARSE_C
646 #ifdef POLARSSL_X509_CRT_PARSE_C
647  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_SIGNATURE + POLARSSL_ERR_ASN1_INVALID_DATA" ) == 0 )
648  {
650  return( 0 );
651  }
652 #endif // POLARSSL_X509_CRT_PARSE_C
653 #ifdef POLARSSL_X509_CSR_PARSE_C
654  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT + POLARSSL_ERR_ASN1_LENGTH_MISMATCH" ) == 0 )
655  {
657  return( 0 );
658  }
659 #endif // POLARSSL_X509_CSR_PARSE_C
660 #ifdef POLARSSL_X509_CRT_PARSE_C
661  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT + POLARSSL_ERR_ASN1_LENGTH_MISMATCH" ) == 0 )
662  {
664  return( 0 );
665  }
666 #endif // POLARSSL_X509_CRT_PARSE_C
667 #ifdef POLARSSL_X509_CRL_PARSE_C
668  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT + POLARSSL_ERR_ASN1_LENGTH_MISMATCH" ) == 0 )
669  {
671  return( 0 );
672  }
673 #endif // POLARSSL_X509_CRL_PARSE_C
674 #ifdef POLARSSL_X509_CRT_PARSE_C
675 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
676  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_OID_NOT_FOUND" ) == 0 )
677  {
679  return( 0 );
680  }
681 #endif // POLARSSL_X509_CRT_PARSE_C
682 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
683 #ifdef POLARSSL_X509_CRL_PARSE_C
684  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_DATE + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
685  {
687  return( 0 );
688  }
689 #endif // POLARSSL_X509_CRL_PARSE_C
690 #ifdef POLARSSL_X509_CRT_PARSE_C
691 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
692  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
693  {
695  return( 0 );
696  }
697 #endif // POLARSSL_X509_CRT_PARSE_C
698 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
699 #ifdef POLARSSL_X509_CSR_PARSE_C
700  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
701  {
703  return( 0 );
704  }
705 #endif // POLARSSL_X509_CSR_PARSE_C
706 #ifdef POLARSSL_X509_CRT_PARSE_C
707  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
708  {
710  return( 0 );
711  }
712 #endif // POLARSSL_X509_CRT_PARSE_C
713 #ifdef POLARSSL_X509_CRL_PARSE_C
714  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
715  {
717  return( 0 );
718  }
719 #endif // POLARSSL_X509_CRL_PARSE_C
720 #ifdef POLARSSL_X509_CRT_PARSE_C
721  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_DATE" ) == 0 )
722  {
723  *value = ( POLARSSL_ERR_X509_INVALID_DATE );
724  return( 0 );
725  }
726 #endif // POLARSSL_X509_CRT_PARSE_C
727 #ifdef POLARSSL_X509_CRT_PARSE_C
728 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
729  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG" ) == 0 )
730  {
731  *value = ( POLARSSL_ERR_X509_INVALID_ALG );
732  return( 0 );
733  }
734 #endif // POLARSSL_X509_CRT_PARSE_C
735 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
736 #ifdef POLARSSL_X509_USE_C
737  if( strcmp( str, "POLARSSL_ERR_OID_BUF_TOO_SMALL" ) == 0 )
738  {
739  *value = ( POLARSSL_ERR_OID_BUF_TOO_SMALL );
740  return( 0 );
741  }
742 #endif // POLARSSL_X509_USE_C
743 #ifdef POLARSSL_X509_CSR_PARSE_C
744  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT" ) == 0 )
745  {
747  return( 0 );
748  }
749 #endif // POLARSSL_X509_CSR_PARSE_C
750 #ifdef POLARSSL_X509_CRT_PARSE_C
751  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT" ) == 0 )
752  {
754  return( 0 );
755  }
756 #endif // POLARSSL_X509_CRT_PARSE_C
757 #ifdef POLARSSL_X509_CRL_PARSE_C
758  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT" ) == 0 )
759  {
761  return( 0 );
762  }
763 #endif // POLARSSL_X509_CRL_PARSE_C
764 #ifdef POLARSSL_X509_CRT_PARSE_C
765 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
766  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_INVALID_DATA" ) == 0 )
767  {
769  return( 0 );
770  }
771 #endif // POLARSSL_X509_CRT_PARSE_C
772 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
773 #ifdef POLARSSL_X509_CRT_PARSE_C
774  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_DATE + POLARSSL_ERR_ASN1_LENGTH_MISMATCH" ) == 0 )
775  {
777  return( 0 );
778  }
779 #endif // POLARSSL_X509_CRT_PARSE_C
780 #ifdef POLARSSL_FS_IO
781 #ifdef POLARSSL_X509_CRT_PARSE_C
782 #ifdef POLARSSL_X509_CRL_PARSE_C
783  if( strcmp( str, "BADCRL_NOT_TRUSTED" ) == 0 )
784  {
785  *value = ( BADCRL_NOT_TRUSTED );
786  return( 0 );
787  }
788 #endif // POLARSSL_FS_IO
789 #endif // POLARSSL_X509_CRT_PARSE_C
790 #endif // POLARSSL_X509_CRL_PARSE_C
791 #ifdef POLARSSL_X509_CSR_PARSE_C
792  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_NAME + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
793  {
795  return( 0 );
796  }
797 #endif // POLARSSL_X509_CSR_PARSE_C
798 #ifdef POLARSSL_X509_CRT_PARSE_C
799  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_NAME + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
800  {
802  return( 0 );
803  }
804 #endif // POLARSSL_X509_CRT_PARSE_C
805 #ifdef POLARSSL_X509_CRL_PARSE_C
806  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_NAME + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
807  {
809  return( 0 );
810  }
811 #endif // POLARSSL_X509_CRL_PARSE_C
812 #ifdef POLARSSL_X509_CRT_PARSE_C
813  if( strcmp( str, "POLARSSL_ERR_PK_INVALID_PUBKEY + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
814  {
816  return( 0 );
817  }
818 #endif // POLARSSL_X509_CRT_PARSE_C
819 #ifdef POLARSSL_FS_IO
820 #ifdef POLARSSL_X509_CRT_PARSE_C
821 #ifdef POLARSSL_X509_CHECK_KEY_USAGE
822  if( strcmp( str, "KU_KEY_CERT_SIGN|KU_CRL_SIGN" ) == 0 )
823  {
824  *value = ( KU_KEY_CERT_SIGN|KU_CRL_SIGN );
825  return( 0 );
826  }
827 #endif // POLARSSL_FS_IO
828 #endif // POLARSSL_X509_CRT_PARSE_C
829 #endif // POLARSSL_X509_CHECK_KEY_USAGE
830 #ifdef POLARSSL_X509_CSR_PARSE_C
831  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_VERSION + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
832  {
834  return( 0 );
835  }
836 #endif // POLARSSL_X509_CSR_PARSE_C
837 #ifdef POLARSSL_X509_CRT_PARSE_C
838  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_VERSION + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
839  {
841  return( 0 );
842  }
843 #endif // POLARSSL_X509_CRT_PARSE_C
844 #ifdef POLARSSL_X509_CRL_PARSE_C
845  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_VERSION + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
846  {
848  return( 0 );
849  }
850 #endif // POLARSSL_X509_CRL_PARSE_C
851 #ifdef POLARSSL_X509_CRT_PARSE_C
852  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_EXTENSIONS + POLARSSL_ERR_ASN1_LENGTH_MISMATCH" ) == 0 )
853  {
855  return( 0 );
856  }
857 #endif // POLARSSL_X509_CRT_PARSE_C
858 #ifdef POLARSSL_X509_CSR_PARSE_C
859  if( strcmp( str, "POLARSSL_ERR_X509_UNKNOWN_VERSION" ) == 0 )
860  {
862  return( 0 );
863  }
864 #endif // POLARSSL_X509_CSR_PARSE_C
865 #ifdef POLARSSL_X509_CRT_PARSE_C
866  if( strcmp( str, "POLARSSL_ERR_X509_UNKNOWN_VERSION" ) == 0 )
867  {
869  return( 0 );
870  }
871 #endif // POLARSSL_X509_CRT_PARSE_C
872 #ifdef POLARSSL_X509_CRL_PARSE_C
873  if( strcmp( str, "POLARSSL_ERR_X509_UNKNOWN_VERSION" ) == 0 )
874  {
876  return( 0 );
877  }
878 #endif // POLARSSL_X509_CRL_PARSE_C
879 #ifdef POLARSSL_X509_CRT_PARSE_C
880 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
881  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
882  {
884  return( 0 );
885  }
886 #endif // POLARSSL_X509_CRT_PARSE_C
887 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
888 #ifdef POLARSSL_X509_CSR_PARSE_C
889  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
890  {
892  return( 0 );
893  }
894 #endif // POLARSSL_X509_CSR_PARSE_C
895 #ifdef POLARSSL_X509_CRT_PARSE_C
896  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
897  {
899  return( 0 );
900  }
901 #endif // POLARSSL_X509_CRT_PARSE_C
902 #ifdef POLARSSL_X509_CRL_PARSE_C
903  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
904  {
906  return( 0 );
907  }
908 #endif // POLARSSL_X509_CRL_PARSE_C
909 #ifdef POLARSSL_X509_CRT_PARSE_C
910  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_VERSION + POLARSSL_ERR_ASN1_LENGTH_MISMATCH" ) == 0 )
911  {
913  return( 0 );
914  }
915 #endif // POLARSSL_X509_CRT_PARSE_C
916 #ifdef POLARSSL_X509_CRT_PARSE_C
917  if( strcmp( str, "POLARSSL_ERR_PK_UNKNOWN_PK_ALG" ) == 0 )
918  {
919  *value = ( POLARSSL_ERR_PK_UNKNOWN_PK_ALG );
920  return( 0 );
921  }
922 #endif // POLARSSL_X509_CRT_PARSE_C
923 #ifdef POLARSSL_X509_CSR_PARSE_C
924  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_SIGNATURE + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
925  {
927  return( 0 );
928  }
929 #endif // POLARSSL_X509_CSR_PARSE_C
930 #ifdef POLARSSL_X509_CRT_PARSE_C
931  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_VERSION + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
932  {
934  return( 0 );
935  }
936 #endif // POLARSSL_X509_CRT_PARSE_C
937 #ifdef POLARSSL_X509_CRT_PARSE_C
938  if( strcmp( str, "POLARSSL_ERR_PK_INVALID_PUBKEY + POLARSSL_ERR_ASN1_LENGTH_MISMATCH" ) == 0 )
939  {
941  return( 0 );
942  }
943 #endif // POLARSSL_X509_CRT_PARSE_C
944 #ifdef POLARSSL_X509_CRT_PARSE_C
945  if( strcmp( str, "POLARSSL_ERR_X509_SIG_MISMATCH" ) == 0 )
946  {
947  *value = ( POLARSSL_ERR_X509_SIG_MISMATCH );
948  return( 0 );
949  }
950 #endif // POLARSSL_X509_CRT_PARSE_C
951 #ifdef POLARSSL_X509_CRL_PARSE_C
952  if( strcmp( str, "POLARSSL_ERR_X509_SIG_MISMATCH" ) == 0 )
953  {
954  *value = ( POLARSSL_ERR_X509_SIG_MISMATCH );
955  return( 0 );
956  }
957 #endif // POLARSSL_X509_CRL_PARSE_C
958 #ifdef POLARSSL_FS_IO
959 #ifdef POLARSSL_X509_CRT_PARSE_C
960 #ifdef POLARSSL_X509_CRL_PARSE_C
961  if( strcmp( str, "BADCERT_NOT_TRUSTED" ) == 0 )
962  {
963  *value = ( BADCERT_NOT_TRUSTED );
964  return( 0 );
965  }
966 #endif // POLARSSL_FS_IO
967 #endif // POLARSSL_X509_CRT_PARSE_C
968 #endif // POLARSSL_X509_CRL_PARSE_C
969 #ifdef POLARSSL_X509_CRT_PARSE_C
970  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_VERSION + POLARSSL_ERR_ASN1_INVALID_LENGTH" ) == 0 )
971  {
973  return( 0 );
974  }
975 #endif // POLARSSL_X509_CRT_PARSE_C
976 #ifdef POLARSSL_X509_CRT_PARSE_C
977  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_SERIAL + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
978  {
980  return( 0 );
981  }
982 #endif // POLARSSL_X509_CRT_PARSE_C
983 #ifdef POLARSSL_X509_CSR_PARSE_C
984  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
985  {
987  return( 0 );
988  }
989 #endif // POLARSSL_X509_CSR_PARSE_C
990 #ifdef POLARSSL_X509_CRT_PARSE_C
991  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
992  {
994  return( 0 );
995  }
996 #endif // POLARSSL_X509_CRT_PARSE_C
997 #ifdef POLARSSL_X509_CRL_PARSE_C
998  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
999  {
1001  return( 0 );
1002  }
1003 #endif // POLARSSL_X509_CRL_PARSE_C
1004 #ifdef POLARSSL_X509_CRT_PARSE_C
1005  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_DATE + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
1006  {
1008  return( 0 );
1009  }
1010 #endif // POLARSSL_X509_CRT_PARSE_C
1011 #ifdef POLARSSL_X509_CRL_PARSE_C
1012  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_DATE + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
1013  {
1015  return( 0 );
1016  }
1017 #endif // POLARSSL_X509_CRL_PARSE_C
1018 #ifdef POLARSSL_FS_IO
1019 #ifdef POLARSSL_X509_CRT_PARSE_C
1020 #ifdef POLARSSL_X509_CRL_PARSE_C
1021  if( strcmp( str, "BADCERT_EXPIRED" ) == 0 )
1022  {
1023  *value = ( BADCERT_EXPIRED );
1024  return( 0 );
1025  }
1026 #endif // POLARSSL_FS_IO
1027 #endif // POLARSSL_X509_CRT_PARSE_C
1028 #endif // POLARSSL_X509_CRL_PARSE_C
1029 #ifdef POLARSSL_FS_IO
1030 #ifdef POLARSSL_X509_CRT_PARSE_C
1031 #ifdef POLARSSL_X509_CRL_PARSE_C
1032  if( strcmp( str, "BADCERT_REVOKED | BADCRL_FUTURE" ) == 0 )
1033  {
1034  *value = ( BADCERT_REVOKED | BADCRL_FUTURE );
1035  return( 0 );
1036  }
1037 #endif // POLARSSL_FS_IO
1038 #endif // POLARSSL_X509_CRT_PARSE_C
1039 #endif // POLARSSL_X509_CRL_PARSE_C
1040 #ifdef POLARSSL_FS_IO
1041 #ifdef POLARSSL_X509_CRT_PARSE_C
1042 #ifdef POLARSSL_X509_CRL_PARSE_C
1043  if( strcmp( str, "BADCERT_REVOKED" ) == 0 )
1044  {
1045  *value = ( BADCERT_REVOKED );
1046  return( 0 );
1047  }
1048 #endif // POLARSSL_FS_IO
1049 #endif // POLARSSL_X509_CRT_PARSE_C
1050 #endif // POLARSSL_X509_CRL_PARSE_C
1051 #ifdef POLARSSL_FS_IO
1052 #ifdef POLARSSL_X509_CRT_PARSE_C
1053 #ifdef POLARSSL_X509_CRL_PARSE_C
1054  if( strcmp( str, "BADCRL_FUTURE" ) == 0 )
1055  {
1056  *value = ( BADCRL_FUTURE );
1057  return( 0 );
1058  }
1059 #endif // POLARSSL_FS_IO
1060 #endif // POLARSSL_X509_CRT_PARSE_C
1061 #endif // POLARSSL_X509_CRL_PARSE_C
1062 #ifdef POLARSSL_X509_CRT_PARSE_C
1063  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_EXTENSIONS + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
1064  {
1066  return( 0 );
1067  }
1068 #endif // POLARSSL_X509_CRT_PARSE_C
1069 #ifdef POLARSSL_FS_IO
1070 #ifdef POLARSSL_X509_CRT_PARSE_C
1071 #ifdef POLARSSL_X509_CHECK_KEY_USAGE
1072  if( strcmp( str, "KU_KEY_CERT_SIGN" ) == 0 )
1073  {
1074  *value = ( KU_KEY_CERT_SIGN );
1075  return( 0 );
1076  }
1077 #endif // POLARSSL_FS_IO
1078 #endif // POLARSSL_X509_CRT_PARSE_C
1079 #endif // POLARSSL_X509_CHECK_KEY_USAGE
1080 #ifdef POLARSSL_FS_IO
1081 #ifdef POLARSSL_X509_CRT_PARSE_C
1082 #ifdef POLARSSL_X509_CHECK_KEY_USAGE
1083  if( strcmp( str, "KU_DIGITAL_SIGNATURE|KU_KEY_ENCIPHERMENT" ) == 0 )
1084  {
1086  return( 0 );
1087  }
1088 #endif // POLARSSL_FS_IO
1089 #endif // POLARSSL_X509_CRT_PARSE_C
1090 #endif // POLARSSL_X509_CHECK_KEY_USAGE
1091 #ifdef POLARSSL_X509_CRT_PARSE_C
1092  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_EXTENSIONS + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
1093  {
1095  return( 0 );
1096  }
1097 #endif // POLARSSL_X509_CRT_PARSE_C
1098 #ifdef POLARSSL_X509_CSR_PARSE_C
1099  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
1100  {
1102  return( 0 );
1103  }
1104 #endif // POLARSSL_X509_CSR_PARSE_C
1105 #ifdef POLARSSL_X509_CRT_PARSE_C
1106  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT + POLARSSL_ERR_ASN1_UNEXPECTED_TAG" ) == 0 )
1107  {
1109  return( 0 );
1110  }
1111 #endif // POLARSSL_X509_CRT_PARSE_C
1112 #ifdef POLARSSL_FS_IO
1113 #ifdef POLARSSL_X509_CRT_PARSE_C
1114 #ifdef POLARSSL_X509_CHECK_KEY_USAGE
1115  if( strcmp( str, "KU_DIGITAL_SIGNATURE" ) == 0 )
1116  {
1117  *value = ( KU_DIGITAL_SIGNATURE );
1118  return( 0 );
1119  }
1120 #endif // POLARSSL_FS_IO
1121 #endif // POLARSSL_X509_CRT_PARSE_C
1122 #endif // POLARSSL_X509_CHECK_KEY_USAGE
1123 #ifdef POLARSSL_X509_CRT_PARSE_C
1124 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
1125  if( strcmp( str, "POLARSSL_MD_SHA1" ) == 0 )
1126  {
1127  *value = ( POLARSSL_MD_SHA1 );
1128  return( 0 );
1129  }
1130 #endif // POLARSSL_X509_CRT_PARSE_C
1131 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
1132 #ifdef POLARSSL_X509_CRT_PARSE_C
1133  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_FORMAT + POLARSSL_ERR_ASN1_INVALID_LENGTH" ) == 0 )
1134  {
1136  return( 0 );
1137  }
1138 #endif // POLARSSL_X509_CRT_PARSE_C
1139 #ifdef POLARSSL_FS_IO
1140 #ifdef POLARSSL_X509_CRT_PARSE_C
1141 #ifdef POLARSSL_X509_CRL_PARSE_C
1142  if( strcmp( str, "BADCERT_OTHER" ) == 0 )
1143  {
1144  *value = ( BADCERT_OTHER );
1145  return( 0 );
1146  }
1147 #endif // POLARSSL_FS_IO
1148 #endif // POLARSSL_X509_CRT_PARSE_C
1149 #endif // POLARSSL_X509_CRL_PARSE_C
1150 #ifdef POLARSSL_X509_CRT_PARSE_C
1151 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
1152  if( strcmp( str, "POLARSSL_MD_SHA256" ) == 0 )
1153  {
1154  *value = ( POLARSSL_MD_SHA256 );
1155  return( 0 );
1156  }
1157 #endif // POLARSSL_X509_CRT_PARSE_C
1158 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
1159 #ifdef POLARSSL_FS_IO
1160 #ifdef POLARSSL_X509_CRT_PARSE_C
1161 #ifdef POLARSSL_X509_CHECK_KEY_USAGE
1162  if( strcmp( str, "KU_KEY_ENCIPHERMENT|KU_KEY_AGREEMENT" ) == 0 )
1163  {
1165  return( 0 );
1166  }
1167 #endif // POLARSSL_FS_IO
1168 #endif // POLARSSL_X509_CRT_PARSE_C
1169 #endif // POLARSSL_X509_CHECK_KEY_USAGE
1170 #ifdef POLARSSL_X509_CRT_PARSE_C
1171  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_SERIAL + POLARSSL_ERR_ASN1_OUT_OF_DATA" ) == 0 )
1172  {
1174  return( 0 );
1175  }
1176 #endif // POLARSSL_X509_CRT_PARSE_C
1177 #ifdef POLARSSL_FS_IO
1178 #ifdef POLARSSL_X509_CRT_PARSE_C
1179 #ifdef POLARSSL_X509_CRL_PARSE_C
1180  if( strcmp( str, "BADCERT_REVOKED | BADCRL_FUTURE | BADCERT_CN_MISMATCH" ) == 0 )
1181  {
1183  return( 0 );
1184  }
1185 #endif // POLARSSL_FS_IO
1186 #endif // POLARSSL_X509_CRT_PARSE_C
1187 #endif // POLARSSL_X509_CRL_PARSE_C
1188 #ifdef POLARSSL_X509_CRT_PARSE_C
1189  if( strcmp( str, "POLARSSL_ERR_PK_INVALID_PUBKEY + POLARSSL_ERR_ASN1_INVALID_DATA" ) == 0 )
1190  {
1192  return( 0 );
1193  }
1194 #endif // POLARSSL_X509_CRT_PARSE_C
1195 #ifdef POLARSSL_X509_CRT_PARSE_C
1196 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
1197  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_LENGTH_MISMATCH" ) == 0 )
1198  {
1200  return( 0 );
1201  }
1202 #endif // POLARSSL_X509_CRT_PARSE_C
1203 #endif // POLARSSL_X509_RSASSA_PSS_SUPPORT
1204 #ifdef POLARSSL_X509_CRT_PARSE_C
1205  if( strcmp( str, "POLARSSL_ERR_X509_INVALID_ALG + POLARSSL_ERR_ASN1_LENGTH_MISMATCH" ) == 0 )
1206  {
1208  return( 0 );
1209  }
1210 #endif // POLARSSL_X509_CRT_PARSE_C
1211 #ifdef POLARSSL_FS_IO
1212 #ifdef POLARSSL_X509_CRT_PARSE_C
1213 #ifdef POLARSSL_X509_CRL_PARSE_C
1214  if( strcmp( str, "BADCERT_REVOKED | BADCRL_EXPIRED | BADCERT_CN_MISMATCH" ) == 0 )
1215  {
1217  return( 0 );
1218  }
1219 #endif // POLARSSL_FS_IO
1220 #endif // POLARSSL_X509_CRT_PARSE_C
1221 #endif // POLARSSL_X509_CRL_PARSE_C
1222 #ifdef POLARSSL_X509_CSR_PARSE_C
1223  if( strcmp( str, "POLARSSL_ERR_X509_UNKNOWN_SIG_ALG" ) == 0 )
1224  {
1225  *value = ( POLARSSL_ERR_X509_UNKNOWN_SIG_ALG );
1226  return( 0 );
1227  }
1228 #endif // POLARSSL_X509_CSR_PARSE_C
1229 #ifdef POLARSSL_X509_CRL_PARSE_C
1230  if( strcmp( str, "POLARSSL_ERR_X509_UNKNOWN_SIG_ALG" ) == 0 )
1231  {
1232  *value = ( POLARSSL_ERR_X509_UNKNOWN_SIG_ALG );
1233  return( 0 );
1234  }
1235 #endif // POLARSSL_X509_CRL_PARSE_C
1236 #ifdef POLARSSL_FS_IO
1237 #ifdef POLARSSL_X509_CRT_PARSE_C
1238 #ifdef POLARSSL_X509_CRL_PARSE_C
1239  if( strcmp( str, "BADCERT_CN_MISMATCH + BADCERT_NOT_TRUSTED" ) == 0 )
1240  {
1242  return( 0 );
1243  }
1244 #endif // POLARSSL_FS_IO
1245 #endif // POLARSSL_X509_CRT_PARSE_C
1246 #endif // POLARSSL_X509_CRL_PARSE_C
1247 #ifdef POLARSSL_X509_CRT_PARSE_C
1248  if( strcmp( str, "POLARSSL_ERR_PK_INVALID_PUBKEY" ) == 0 )
1249  {
1250  *value = ( POLARSSL_ERR_PK_INVALID_PUBKEY );
1251  return( 0 );
1252  }
1253 #endif // POLARSSL_X509_CRT_PARSE_C
1254 
1255 
1256  printf( "Expected integer for parameter and got: %s\n", str );
1257  return( -1 );
1258 }
1259 
1260 #ifdef POLARSSL_FS_IO
1261 #ifdef POLARSSL_X509_CRT_PARSE_C
1262 void test_suite_x509_cert_info( char *crt_file, char *result_str )
1263 {
1264  x509_crt crt;
1265  char buf[2000];
1266  int res;
1267 
1268  x509_crt_init( &crt );
1269  memset( buf, 0, 2000 );
1270 
1271  TEST_ASSERT( x509_crt_parse_file( &crt, crt_file ) == 0 );
1272  res = x509_crt_info( buf, 2000, "", &crt );
1273 
1274  TEST_ASSERT( res != -1 );
1275  TEST_ASSERT( res != -2 );
1276 
1277  TEST_ASSERT( strcmp( buf, result_str ) == 0 );
1278 
1279 exit:
1280  x509_crt_free( &crt );
1281 }
1282 #endif /* POLARSSL_FS_IO */
1283 #endif /* POLARSSL_X509_CRT_PARSE_C */
1284 
1285 #ifdef POLARSSL_FS_IO
1286 #ifdef POLARSSL_X509_CRL_PARSE_C
1287 void test_suite_x509_crl_info( char *crl_file, char *result_str )
1288 {
1289  x509_crl crl;
1290  char buf[2000];
1291  int res;
1292 
1293  x509_crl_init( &crl );
1294  memset( buf, 0, 2000 );
1295 
1296  TEST_ASSERT( x509_crl_parse_file( &crl, crl_file ) == 0 );
1297  res = x509_crl_info( buf, 2000, "", &crl );
1298 
1299  TEST_ASSERT( res != -1 );
1300  TEST_ASSERT( res != -2 );
1301 
1302  TEST_ASSERT( strcmp( buf, result_str ) == 0 );
1303 
1304 exit:
1305  x509_crl_free( &crl );
1306 }
1307 #endif /* POLARSSL_FS_IO */
1308 #endif /* POLARSSL_X509_CRL_PARSE_C */
1309 
1310 #ifdef POLARSSL_FS_IO
1311 #ifdef POLARSSL_X509_CSR_PARSE_C
1312 void test_suite_x509_csr_info( char *csr_file, char *result_str )
1313 {
1314  x509_csr csr;
1315  char buf[2000];
1316  int res;
1317 
1318  x509_csr_init( &csr );
1319  memset( buf, 0, 2000 );
1320 
1321  TEST_ASSERT( x509_csr_parse_file( &csr, csr_file ) == 0 );
1322  res = x509_csr_info( buf, 2000, "", &csr );
1323 
1324  TEST_ASSERT( res != -1 );
1325  TEST_ASSERT( res != -2 );
1326 
1327  TEST_ASSERT( strcmp( buf, result_str ) == 0 );
1328 
1329 exit:
1330  x509_csr_free( &csr );
1331 }
1332 #endif /* POLARSSL_FS_IO */
1333 #endif /* POLARSSL_X509_CSR_PARSE_C */
1334 
1335 #ifdef POLARSSL_FS_IO
1336 #ifdef POLARSSL_X509_CRT_PARSE_C
1337 #ifdef POLARSSL_X509_CRL_PARSE_C
1338 void test_suite_x509_verify( char *crt_file, char *ca_file, char *crl_file,
1339  char *cn_name_str, int result, int flags_result,
1340  char *verify_callback )
1341 {
1342  x509_crt crt;
1343  x509_crt ca;
1344  x509_crl crl;
1345  int flags = 0;
1346  int res;
1347  int (*f_vrfy)(void *, x509_crt *, int, int *) = NULL;
1348  char * cn_name = NULL;
1349 
1350  x509_crt_init( &crt );
1351  x509_crt_init( &ca );
1352  x509_crl_init( &crl );
1353 
1354  if( strcmp( cn_name_str, "NULL" ) != 0 )
1355  cn_name = cn_name_str;
1356 
1357  if( strcmp( verify_callback, "NULL" ) == 0 )
1358  f_vrfy = NULL;
1359  else if( strcmp( verify_callback, "verify_none" ) == 0 )
1360  f_vrfy = verify_none;
1361  else if( strcmp( verify_callback, "verify_all" ) == 0 )
1362  f_vrfy = verify_all;
1363  else
1364  TEST_ASSERT( "No known verify callback selected" == 0 );
1365 
1366  TEST_ASSERT( x509_crt_parse_file( &crt, crt_file ) == 0 );
1367  TEST_ASSERT( x509_crt_parse_file( &ca, ca_file ) == 0 );
1368  TEST_ASSERT( x509_crl_parse_file( &crl, crl_file ) == 0 );
1369 
1370  res = x509_crt_verify( &crt, &ca, &crl, cn_name, &flags, f_vrfy, NULL );
1371 
1372  TEST_ASSERT( res == ( result ) );
1373  TEST_ASSERT( flags == ( flags_result ) );
1374 
1375 exit:
1376  x509_crt_free( &crt );
1377  x509_crt_free( &ca );
1378  x509_crl_free( &crl );
1379 }
1380 #endif /* POLARSSL_FS_IO */
1381 #endif /* POLARSSL_X509_CRT_PARSE_C */
1382 #endif /* POLARSSL_X509_CRL_PARSE_C */
1383 
1384 #ifdef POLARSSL_FS_IO
1385 #ifdef POLARSSL_X509_CRT_C
1386 void test_suite_x509_dn_gets( char *crt_file, char *entity, char *result_str )
1387 {
1388  x509_crt crt;
1389  char buf[2000];
1390  int res = 0;
1391 
1392  x509_crt_init( &crt );
1393  memset( buf, 0, 2000 );
1394 
1395  TEST_ASSERT( x509_crt_parse_file( &crt, crt_file ) == 0 );
1396  if( strcmp( entity, "subject" ) == 0 )
1397  res = x509_dn_gets( buf, 2000, &crt.subject );
1398  else if( strcmp( entity, "issuer" ) == 0 )
1399  res = x509_dn_gets( buf, 2000, &crt.issuer );
1400  else
1401  TEST_ASSERT( "Unknown entity" == 0 );
1402 
1403  TEST_ASSERT( res != -1 );
1404  TEST_ASSERT( res != -2 );
1405 
1406  TEST_ASSERT( strcmp( buf, result_str ) == 0 );
1407 
1408 exit:
1409  x509_crt_free( &crt );
1410 }
1411 #endif /* POLARSSL_FS_IO */
1412 #endif /* POLARSSL_X509_CRT_C */
1413 
1414 #ifdef POLARSSL_FS_IO
1415 #ifdef POLARSSL_X509_CRT_C
1416 void test_suite_x509_time_expired( char *crt_file, char *entity, int result )
1417 {
1418  x509_crt crt;
1419 
1420  x509_crt_init( &crt );
1421 
1422  TEST_ASSERT( x509_crt_parse_file( &crt, crt_file ) == 0 );
1423 
1424  if( strcmp( entity, "valid_from" ) == 0 )
1425  TEST_ASSERT( x509_time_expired( &crt.valid_from ) == result );
1426  else if( strcmp( entity, "valid_to" ) == 0 )
1427  TEST_ASSERT( x509_time_expired( &crt.valid_to ) == result );
1428  else
1429  TEST_ASSERT( "Unknown entity" == 0 );
1430 
1431 exit:
1432  x509_crt_free( &crt );
1433 }
1434 #endif /* POLARSSL_FS_IO */
1435 #endif /* POLARSSL_X509_CRT_C */
1436 
1437 #ifdef POLARSSL_FS_IO
1438 #ifdef POLARSSL_X509_CRT_C
1439 void test_suite_x509_time_future( char *crt_file, char *entity, int result )
1440 {
1441  x509_crt crt;
1442 
1443  x509_crt_init( &crt );
1444 
1445  TEST_ASSERT( x509_crt_parse_file( &crt, crt_file ) == 0 );
1446 
1447  if( strcmp( entity, "valid_from" ) == 0 )
1448  TEST_ASSERT( x509_time_future( &crt.valid_from ) == result );
1449  else if( strcmp( entity, "valid_to" ) == 0 )
1450  TEST_ASSERT( x509_time_future( &crt.valid_to ) == result );
1451  else
1452  TEST_ASSERT( "Unknown entity" == 0 );
1453 
1454 exit:
1455  x509_crt_free( &crt );
1456 }
1457 #endif /* POLARSSL_FS_IO */
1458 #endif /* POLARSSL_X509_CRT_C */
1459 
1460 #ifdef POLARSSL_X509_CRT_PARSE_C
1461 void test_suite_x509parse_crt( char *crt_data, char *result_str, int result )
1462 {
1463  x509_crt crt;
1464  unsigned char buf[2000];
1465  unsigned char output[2000];
1466  int data_len, res;
1467 
1468  x509_crt_init( &crt );
1469  memset( buf, 0, 2000 );
1470  memset( output, 0, 2000 );
1471 
1472  data_len = unhexify( buf, crt_data );
1473 
1474  TEST_ASSERT( x509_crt_parse( &crt, buf, data_len ) == ( result ) );
1475  if( ( result ) == 0 )
1476  {
1477  res = x509_crt_info( (char *) output, 2000, "", &crt );
1478 
1479  TEST_ASSERT( res != -1 );
1480  TEST_ASSERT( res != -2 );
1481 
1482  TEST_ASSERT( strcmp( (char *) output, result_str ) == 0 );
1483  }
1484 
1485 exit:
1486  x509_crt_free( &crt );
1487 }
1488 #endif /* POLARSSL_X509_CRT_PARSE_C */
1489 
1490 #ifdef POLARSSL_X509_CRL_PARSE_C
1491 void test_suite_x509parse_crl( char *crl_data, char *result_str, int result )
1492 {
1493  x509_crl crl;
1494  unsigned char buf[2000];
1495  unsigned char output[2000];
1496  int data_len, res;
1497 
1498  x509_crl_init( &crl );
1499  memset( buf, 0, 2000 );
1500  memset( output, 0, 2000 );
1501 
1502  data_len = unhexify( buf, crl_data );
1503 
1504  TEST_ASSERT( x509_crl_parse( &crl, buf, data_len ) == ( result ) );
1505  if( ( result ) == 0 )
1506  {
1507  res = x509_crl_info( (char *) output, 2000, "", &crl );
1508 
1509  TEST_ASSERT( res != -1 );
1510  TEST_ASSERT( res != -2 );
1511 
1512  TEST_ASSERT( strcmp( (char *) output, result_str ) == 0 );
1513  }
1514 
1515 exit:
1516  x509_crl_free( &crl );
1517 }
1518 #endif /* POLARSSL_X509_CRL_PARSE_C */
1519 
1520 #ifdef POLARSSL_X509_CSR_PARSE_C
1521 void test_suite_x509_csr_parse( char *csr_der_hex, char *ref_out, int ref_ret )
1522 {
1523  x509_csr csr;
1524  unsigned char *csr_der = NULL;
1525  char my_out[1000];
1526  size_t csr_der_len;
1527  int my_ret;
1528 
1529  x509_csr_init( &csr );
1530  memset( my_out, 0, sizeof( my_out ) );
1531  csr_der = unhexify_alloc( csr_der_hex, &csr_der_len );
1532 
1533  my_ret = x509_csr_parse_der( &csr, csr_der, csr_der_len );
1534  TEST_ASSERT( my_ret == ref_ret );
1535 
1536  if( ref_ret == 0 )
1537  {
1538  size_t my_out_len = x509_csr_info( my_out, sizeof( my_out ), "", &csr );
1539  TEST_ASSERT( my_out_len == strlen( ref_out ) );
1540  TEST_ASSERT( strcmp( my_out, ref_out ) == 0 );
1541  }
1542 
1543 exit:
1544  x509_csr_free( &csr );
1545  polarssl_free( csr_der );
1546 }
1547 #endif /* POLARSSL_X509_CSR_PARSE_C */
1548 
1549 #ifdef POLARSSL_FS_IO
1550 #ifdef POLARSSL_X509_CRT_PARSE_C
1551 void test_suite_x509_crt_parse_path( char *crt_path, int ret, int nb_crt )
1552 {
1553  x509_crt chain, *cur;
1554  int i;
1555 
1556  x509_crt_init( &chain );
1557 
1558  TEST_ASSERT( x509_crt_parse_path( &chain, crt_path ) == ret );
1559 
1560  /* Check how many certs we got */
1561  for( i = 0, cur = &chain; cur != NULL; cur = cur->next )
1562  if( cur->raw.p != NULL )
1563  i++;
1564 
1565  TEST_ASSERT( i == nb_crt );
1566 
1567 exit:
1568  x509_crt_free( &chain );
1569 }
1570 #endif /* POLARSSL_FS_IO */
1571 #endif /* POLARSSL_X509_CRT_PARSE_C */
1572 
1573 #ifdef POLARSSL_X509_USE_C
1574 void test_suite_x509_oid_desc( char *oid_str, char *ref_desc )
1575 {
1576  x509_buf oid;
1577  const char *desc;
1578  unsigned char buf[20];
1579 
1580  memset( buf, 0, sizeof buf );
1581 
1582  oid.tag = ASN1_OID;
1583  oid.len = unhexify( buf, oid_str );
1584  oid.p = buf;
1585 
1586  desc = x509_oid_get_description( &oid );
1587 
1588  if( strcmp( ref_desc, "notfound" ) == 0 )
1589  TEST_ASSERT( desc == NULL );
1590  else
1591  {
1592  TEST_ASSERT( desc != NULL );
1593  TEST_ASSERT( strcmp( desc, ref_desc ) == 0 );
1594  }
1595 
1596 exit:
1597  return;
1598 }
1599 #endif /* POLARSSL_X509_USE_C */
1600 
1601 #ifdef POLARSSL_X509_USE_C
1602 void test_suite_x509_oid_numstr( char *oid_str, char *numstr, int blen, int ret )
1603 {
1604  x509_buf oid;
1605  unsigned char oid_buf[20];
1606  char num_buf[100];
1607 
1608  memset( oid_buf, 0x00, sizeof oid_buf );
1609  memset( num_buf, 0x2a, sizeof num_buf );
1610 
1611  oid.tag = ASN1_OID;
1612  oid.len = unhexify( oid_buf, oid_str );
1613  oid.p = oid_buf;
1614 
1615  TEST_ASSERT( (size_t) blen <= sizeof num_buf );
1616 
1617  TEST_ASSERT( x509_oid_get_numeric_string( num_buf, blen, &oid ) == ret );
1618 
1619  if( ret >= 0 )
1620  {
1621  TEST_ASSERT( num_buf[ret] == 0 );
1622  TEST_ASSERT( strcmp( num_buf, numstr ) == 0 );
1623  }
1624 
1625 exit:
1626  return;
1627 }
1628 #endif /* POLARSSL_X509_USE_C */
1629 
1630 #ifdef POLARSSL_FS_IO
1631 #ifdef POLARSSL_X509_CRT_PARSE_C
1632 #ifdef POLARSSL_X509_CHECK_KEY_USAGE
1633 void test_suite_x509_check_key_usage( char *crt_file, int usage, int ret )
1634 {
1635  x509_crt crt;
1636 
1637  x509_crt_init( &crt );
1638 
1639  TEST_ASSERT( x509_crt_parse_file( &crt, crt_file ) == 0 );
1640 
1641  TEST_ASSERT( x509_crt_check_key_usage( &crt, usage ) == ret );
1642 
1643 exit:
1644  x509_crt_free( &crt );
1645 }
1646 #endif /* POLARSSL_FS_IO */
1647 #endif /* POLARSSL_X509_CRT_PARSE_C */
1648 #endif /* POLARSSL_X509_CHECK_KEY_USAGE */
1649 
1650 #ifdef POLARSSL_FS_IO
1651 #ifdef POLARSSL_X509_CRT_PARSE_C
1652 #ifdef POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE
1653 void test_suite_x509_check_extended_key_usage( char *crt_file, char *usage_hex, int ret )
1654 {
1655  x509_crt crt;
1656  char oid[50];
1657  size_t len;
1658 
1659  x509_crt_init( &crt );
1660 
1661  len = unhexify( (unsigned char *) oid, usage_hex );
1662 
1663  TEST_ASSERT( x509_crt_parse_file( &crt, crt_file ) == 0 );
1664 
1665  TEST_ASSERT( x509_crt_check_extended_key_usage( &crt, oid, len ) == ret );
1666 
1667 exit:
1668  x509_crt_free( &crt );
1669 }
1670 #endif /* POLARSSL_FS_IO */
1671 #endif /* POLARSSL_X509_CRT_PARSE_C */
1672 #endif /* POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE */
1673 
1674 #ifdef POLARSSL_X509_CRT_PARSE_C
1675 #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
1676 void test_suite_x509_parse_rsassa_pss_params( char *hex_params, int params_tag,
1677  int ref_msg_md, int ref_mgf_md,
1678  int ref_salt_len, int ref_ret )
1679 {
1680  int my_ret;
1681  x509_buf params;
1682  md_type_t my_msg_md, my_mgf_md;
1683  int my_salt_len;
1684 
1685  params.p = unhexify_alloc( hex_params, &params.len );
1686  params.tag = params_tag;
1687 
1688  my_ret = x509_get_rsassa_pss_params( &params, &my_msg_md, &my_mgf_md,
1689  &my_salt_len );
1690 
1691  if( my_ret != ref_ret ) printf( "\n%04X\n", - my_ret );
1692 
1693  TEST_ASSERT( my_ret == ref_ret );
1694 
1695  if( ref_ret == 0 )
1696  {
1697  TEST_ASSERT( my_msg_md == (md_type_t) ref_msg_md );
1698  TEST_ASSERT( my_mgf_md == (md_type_t) ref_mgf_md );
1699  TEST_ASSERT( my_salt_len == ref_salt_len );
1700  }
1701 
1702 exit:
1703  polarssl_free( params.p );
1704 }
1705 #endif /* POLARSSL_X509_CRT_PARSE_C */
1706 #endif /* POLARSSL_X509_RSASSA_PSS_SUPPORT */
1707 
1708 #ifdef POLARSSL_X509_CRT_PARSE_C
1709 #ifdef POLARSSL_SELF_TEST
1710 void test_suite_x509_selftest()
1711 {
1712  TEST_ASSERT( x509_self_test( 0 ) == 0 );
1713 
1714 exit:
1715  return;
1716 }
1717 #endif /* POLARSSL_X509_CRT_PARSE_C */
1718 #endif /* POLARSSL_SELF_TEST */
1719 
1720 
1721 #endif /* POLARSSL_BIGNUM_C */
1722 
1723 
1724 int dep_check( char *str )
1725 {
1726  if( str == NULL )
1727  return( 1 );
1728 
1729  if( strcmp( str, "POLARSSL_CERTS_C" ) == 0 )
1730  {
1731 #if defined(POLARSSL_CERTS_C)
1732  return( 0 );
1733 #else
1734  return( 1 );
1735 #endif
1736  }
1737  if( strcmp( str, "POLARSSL_ECP_DP_SECP384R1_ENABLED" ) == 0 )
1738  {
1739 #if defined(POLARSSL_ECP_DP_SECP384R1_ENABLED)
1740  return( 0 );
1741 #else
1742  return( 1 );
1743 #endif
1744  }
1745  if( strcmp( str, "POLARSSL_SHA1_C" ) == 0 )
1746  {
1747 #if defined(POLARSSL_SHA1_C)
1748  return( 0 );
1749 #else
1750  return( 1 );
1751 #endif
1752  }
1753  if( strcmp( str, "POLARSSL_PEM_PARSE_C" ) == 0 )
1754  {
1755 #if defined(POLARSSL_PEM_PARSE_C)
1756  return( 0 );
1757 #else
1758  return( 1 );
1759 #endif
1760  }
1761  if( strcmp( str, "POLARSSL_SHA256_C" ) == 0 )
1762  {
1763 #if defined(POLARSSL_SHA256_C)
1764  return( 0 );
1765 #else
1766  return( 1 );
1767 #endif
1768  }
1769  if( strcmp( str, "POLARSSL_RSA_C" ) == 0 )
1770  {
1771 #if defined(POLARSSL_RSA_C)
1772  return( 0 );
1773 #else
1774  return( 1 );
1775 #endif
1776  }
1777  if( strcmp( str, "POLARSSL_X509_ALLOW_EXTENSIONS_NON_V3" ) == 0 )
1778  {
1779 #if defined(POLARSSL_X509_ALLOW_EXTENSIONS_NON_V3)
1780  return( 0 );
1781 #else
1782  return( 1 );
1783 #endif
1784  }
1785  if( strcmp( str, "POLARSSL_SHA512_C" ) == 0 )
1786  {
1787 #if defined(POLARSSL_SHA512_C)
1788  return( 0 );
1789 #else
1790  return( 1 );
1791 #endif
1792  }
1793  if( strcmp( str, "POLARSSL_ECP_DP_SECP256R1_ENABLED" ) == 0 )
1794  {
1795 #if defined(POLARSSL_ECP_DP_SECP256R1_ENABLED)
1796  return( 0 );
1797 #else
1798  return( 1 );
1799 #endif
1800  }
1801  if( strcmp( str, "POLARSSL_ECP_DP_SECP383R1_ENABLED" ) == 0 )
1802  {
1803 #if defined(POLARSSL_ECP_DP_SECP383R1_ENABLED)
1804  return( 0 );
1805 #else
1806  return( 1 );
1807 #endif
1808  }
1809  if( strcmp( str, "POLARSSL_MD4_C" ) == 0 )
1810  {
1811 #if defined(POLARSSL_MD4_C)
1812  return( 0 );
1813 #else
1814  return( 1 );
1815 #endif
1816  }
1817  if( strcmp( str, "POLARSSL_PKCS1_V15" ) == 0 )
1818  {
1819 #if defined(POLARSSL_PKCS1_V15)
1820  return( 0 );
1821 #else
1822  return( 1 );
1823 #endif
1824  }
1825  if( strcmp( str, "POLARSSL_HAVE_TIME" ) == 0 )
1826  {
1827 #if defined(POLARSSL_HAVE_TIME)
1828  return( 0 );
1829 #else
1830  return( 1 );
1831 #endif
1832  }
1833  if( strcmp( str, "POLARSSL_X509_CHECK_KEY_USAGE" ) == 0 )
1834  {
1835 #if defined(POLARSSL_X509_CHECK_KEY_USAGE)
1836  return( 0 );
1837 #else
1838  return( 1 );
1839 #endif
1840  }
1841  if( strcmp( str, "POLARSSL_MD5_C" ) == 0 )
1842  {
1843 #if defined(POLARSSL_MD5_C)
1844  return( 0 );
1845 #else
1846  return( 1 );
1847 #endif
1848  }
1849  if( strcmp( str, "POLARSSL_ECDSA_C" ) == 0 )
1850  {
1851 #if defined(POLARSSL_ECDSA_C)
1852  return( 0 );
1853 #else
1854  return( 1 );
1855 #endif
1856  }
1857  if( strcmp( str, "POLARSSL_X509_RSASSA_PSS_SUPPORT" ) == 0 )
1858  {
1859 #if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
1860  return( 0 );
1861 #else
1862  return( 1 );
1863 #endif
1864  }
1865  if( strcmp( str, "POLARSSL_ECP_DP_SECP192R1_ENABLED" ) == 0 )
1866  {
1867 #if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
1868  return( 0 );
1869 #else
1870  return( 1 );
1871 #endif
1872  }
1873  if( strcmp( str, "POLARSSL_ECP_C" ) == 0 )
1874  {
1875 #if defined(POLARSSL_ECP_C)
1876  return( 0 );
1877 #else
1878  return( 1 );
1879 #endif
1880  }
1881 
1882 
1883  return( 1 );
1884 }
1885 
1886 int dispatch_test(int cnt, char *params[50])
1887 {
1888  int ret;
1889  ((void) cnt);
1890  ((void) params);
1891 
1892 #if defined(TEST_SUITE_ACTIVE)
1893  if( strcmp( params[0], "x509_cert_info" ) == 0 )
1894  {
1895  #ifdef POLARSSL_FS_IO
1896  #ifdef POLARSSL_X509_CRT_PARSE_C
1897 
1898  char *param1 = params[1];
1899  char *param2 = params[2];
1900 
1901  if( cnt != 3 )
1902  {
1903  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 3 );
1904  return( 2 );
1905  }
1906 
1907  if( verify_string( &param1 ) != 0 ) return( 2 );
1908  if( verify_string( &param2 ) != 0 ) return( 2 );
1909 
1910  test_suite_x509_cert_info( param1, param2 );
1911  return ( 0 );
1912  #endif /* POLARSSL_FS_IO */
1913  #endif /* POLARSSL_X509_CRT_PARSE_C */
1914 
1915  return ( 3 );
1916  }
1917  else
1918  if( strcmp( params[0], "x509_crl_info" ) == 0 )
1919  {
1920  #ifdef POLARSSL_FS_IO
1921  #ifdef POLARSSL_X509_CRL_PARSE_C
1922 
1923  char *param1 = params[1];
1924  char *param2 = params[2];
1925 
1926  if( cnt != 3 )
1927  {
1928  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 3 );
1929  return( 2 );
1930  }
1931 
1932  if( verify_string( &param1 ) != 0 ) return( 2 );
1933  if( verify_string( &param2 ) != 0 ) return( 2 );
1934 
1935  test_suite_x509_crl_info( param1, param2 );
1936  return ( 0 );
1937  #endif /* POLARSSL_FS_IO */
1938  #endif /* POLARSSL_X509_CRL_PARSE_C */
1939 
1940  return ( 3 );
1941  }
1942  else
1943  if( strcmp( params[0], "x509_csr_info" ) == 0 )
1944  {
1945  #ifdef POLARSSL_FS_IO
1946  #ifdef POLARSSL_X509_CSR_PARSE_C
1947 
1948  char *param1 = params[1];
1949  char *param2 = params[2];
1950 
1951  if( cnt != 3 )
1952  {
1953  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 3 );
1954  return( 2 );
1955  }
1956 
1957  if( verify_string( &param1 ) != 0 ) return( 2 );
1958  if( verify_string( &param2 ) != 0 ) return( 2 );
1959 
1960  test_suite_x509_csr_info( param1, param2 );
1961  return ( 0 );
1962  #endif /* POLARSSL_FS_IO */
1963  #endif /* POLARSSL_X509_CSR_PARSE_C */
1964 
1965  return ( 3 );
1966  }
1967  else
1968  if( strcmp( params[0], "x509_verify" ) == 0 )
1969  {
1970  #ifdef POLARSSL_FS_IO
1971  #ifdef POLARSSL_X509_CRT_PARSE_C
1972  #ifdef POLARSSL_X509_CRL_PARSE_C
1973 
1974  char *param1 = params[1];
1975  char *param2 = params[2];
1976  char *param3 = params[3];
1977  char *param4 = params[4];
1978  int param5;
1979  int param6;
1980  char *param7 = params[7];
1981 
1982  if( cnt != 8 )
1983  {
1984  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 8 );
1985  return( 2 );
1986  }
1987 
1988  if( verify_string( &param1 ) != 0 ) return( 2 );
1989  if( verify_string( &param2 ) != 0 ) return( 2 );
1990  if( verify_string( &param3 ) != 0 ) return( 2 );
1991  if( verify_string( &param4 ) != 0 ) return( 2 );
1992  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1993  if( verify_int( params[6], &param6 ) != 0 ) return( 2 );
1994  if( verify_string( &param7 ) != 0 ) return( 2 );
1995 
1996  test_suite_x509_verify( param1, param2, param3, param4, param5, param6, param7 );
1997  return ( 0 );
1998  #endif /* POLARSSL_FS_IO */
1999  #endif /* POLARSSL_X509_CRT_PARSE_C */
2000  #endif /* POLARSSL_X509_CRL_PARSE_C */
2001 
2002  return ( 3 );
2003  }
2004  else
2005  if( strcmp( params[0], "x509_dn_gets" ) == 0 )
2006  {
2007  #ifdef POLARSSL_FS_IO
2008  #ifdef POLARSSL_X509_CRT_C
2009 
2010  char *param1 = params[1];
2011  char *param2 = params[2];
2012  char *param3 = params[3];
2013 
2014  if( cnt != 4 )
2015  {
2016  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
2017  return( 2 );
2018  }
2019 
2020  if( verify_string( &param1 ) != 0 ) return( 2 );
2021  if( verify_string( &param2 ) != 0 ) return( 2 );
2022  if( verify_string( &param3 ) != 0 ) return( 2 );
2023 
2024  test_suite_x509_dn_gets( param1, param2, param3 );
2025  return ( 0 );
2026  #endif /* POLARSSL_FS_IO */
2027  #endif /* POLARSSL_X509_CRT_C */
2028 
2029  return ( 3 );
2030  }
2031  else
2032  if( strcmp( params[0], "x509_time_expired" ) == 0 )
2033  {
2034  #ifdef POLARSSL_FS_IO
2035  #ifdef POLARSSL_X509_CRT_C
2036 
2037  char *param1 = params[1];
2038  char *param2 = params[2];
2039  int param3;
2040 
2041  if( cnt != 4 )
2042  {
2043  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
2044  return( 2 );
2045  }
2046 
2047  if( verify_string( &param1 ) != 0 ) return( 2 );
2048  if( verify_string( &param2 ) != 0 ) return( 2 );
2049  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2050 
2051  test_suite_x509_time_expired( param1, param2, param3 );
2052  return ( 0 );
2053  #endif /* POLARSSL_FS_IO */
2054  #endif /* POLARSSL_X509_CRT_C */
2055 
2056  return ( 3 );
2057  }
2058  else
2059  if( strcmp( params[0], "x509_time_future" ) == 0 )
2060  {
2061  #ifdef POLARSSL_FS_IO
2062  #ifdef POLARSSL_X509_CRT_C
2063 
2064  char *param1 = params[1];
2065  char *param2 = params[2];
2066  int param3;
2067 
2068  if( cnt != 4 )
2069  {
2070  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
2071  return( 2 );
2072  }
2073 
2074  if( verify_string( &param1 ) != 0 ) return( 2 );
2075  if( verify_string( &param2 ) != 0 ) return( 2 );
2076  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2077 
2078  test_suite_x509_time_future( param1, param2, param3 );
2079  return ( 0 );
2080  #endif /* POLARSSL_FS_IO */
2081  #endif /* POLARSSL_X509_CRT_C */
2082 
2083  return ( 3 );
2084  }
2085  else
2086  if( strcmp( params[0], "x509parse_crt" ) == 0 )
2087  {
2088  #ifdef POLARSSL_X509_CRT_PARSE_C
2089 
2090  char *param1 = params[1];
2091  char *param2 = params[2];
2092  int param3;
2093 
2094  if( cnt != 4 )
2095  {
2096  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
2097  return( 2 );
2098  }
2099 
2100  if( verify_string( &param1 ) != 0 ) return( 2 );
2101  if( verify_string( &param2 ) != 0 ) return( 2 );
2102  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2103 
2104  test_suite_x509parse_crt( param1, param2, param3 );
2105  return ( 0 );
2106  #endif /* POLARSSL_X509_CRT_PARSE_C */
2107 
2108  return ( 3 );
2109  }
2110  else
2111  if( strcmp( params[0], "x509parse_crl" ) == 0 )
2112  {
2113  #ifdef POLARSSL_X509_CRL_PARSE_C
2114 
2115  char *param1 = params[1];
2116  char *param2 = params[2];
2117  int param3;
2118 
2119  if( cnt != 4 )
2120  {
2121  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
2122  return( 2 );
2123  }
2124 
2125  if( verify_string( &param1 ) != 0 ) return( 2 );
2126  if( verify_string( &param2 ) != 0 ) return( 2 );
2127  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2128 
2129  test_suite_x509parse_crl( param1, param2, param3 );
2130  return ( 0 );
2131  #endif /* POLARSSL_X509_CRL_PARSE_C */
2132 
2133  return ( 3 );
2134  }
2135  else
2136  if( strcmp( params[0], "x509_csr_parse" ) == 0 )
2137  {
2138  #ifdef POLARSSL_X509_CSR_PARSE_C
2139 
2140  char *param1 = params[1];
2141  char *param2 = params[2];
2142  int param3;
2143 
2144  if( cnt != 4 )
2145  {
2146  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
2147  return( 2 );
2148  }
2149 
2150  if( verify_string( &param1 ) != 0 ) return( 2 );
2151  if( verify_string( &param2 ) != 0 ) return( 2 );
2152  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2153 
2154  test_suite_x509_csr_parse( param1, param2, param3 );
2155  return ( 0 );
2156  #endif /* POLARSSL_X509_CSR_PARSE_C */
2157 
2158  return ( 3 );
2159  }
2160  else
2161  if( strcmp( params[0], "x509_crt_parse_path" ) == 0 )
2162  {
2163  #ifdef POLARSSL_FS_IO
2164  #ifdef POLARSSL_X509_CRT_PARSE_C
2165 
2166  char *param1 = params[1];
2167  int param2;
2168  int param3;
2169 
2170  if( cnt != 4 )
2171  {
2172  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
2173  return( 2 );
2174  }
2175 
2176  if( verify_string( &param1 ) != 0 ) return( 2 );
2177  if( verify_int( params[2], &param2 ) != 0 ) return( 2 );
2178  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2179 
2180  test_suite_x509_crt_parse_path( param1, param2, param3 );
2181  return ( 0 );
2182  #endif /* POLARSSL_FS_IO */
2183  #endif /* POLARSSL_X509_CRT_PARSE_C */
2184 
2185  return ( 3 );
2186  }
2187  else
2188  if( strcmp( params[0], "x509_oid_desc" ) == 0 )
2189  {
2190  #ifdef POLARSSL_X509_USE_C
2191 
2192  char *param1 = params[1];
2193  char *param2 = params[2];
2194 
2195  if( cnt != 3 )
2196  {
2197  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 3 );
2198  return( 2 );
2199  }
2200 
2201  if( verify_string( &param1 ) != 0 ) return( 2 );
2202  if( verify_string( &param2 ) != 0 ) return( 2 );
2203 
2204  test_suite_x509_oid_desc( param1, param2 );
2205  return ( 0 );
2206  #endif /* POLARSSL_X509_USE_C */
2207 
2208  return ( 3 );
2209  }
2210  else
2211  if( strcmp( params[0], "x509_oid_numstr" ) == 0 )
2212  {
2213  #ifdef POLARSSL_X509_USE_C
2214 
2215  char *param1 = params[1];
2216  char *param2 = params[2];
2217  int param3;
2218  int param4;
2219 
2220  if( cnt != 5 )
2221  {
2222  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
2223  return( 2 );
2224  }
2225 
2226  if( verify_string( &param1 ) != 0 ) return( 2 );
2227  if( verify_string( &param2 ) != 0 ) return( 2 );
2228  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2229  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
2230 
2231  test_suite_x509_oid_numstr( param1, param2, param3, param4 );
2232  return ( 0 );
2233  #endif /* POLARSSL_X509_USE_C */
2234 
2235  return ( 3 );
2236  }
2237  else
2238  if( strcmp( params[0], "x509_check_key_usage" ) == 0 )
2239  {
2240  #ifdef POLARSSL_FS_IO
2241  #ifdef POLARSSL_X509_CRT_PARSE_C
2242  #ifdef POLARSSL_X509_CHECK_KEY_USAGE
2243 
2244  char *param1 = params[1];
2245  int param2;
2246  int param3;
2247 
2248  if( cnt != 4 )
2249  {
2250  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
2251  return( 2 );
2252  }
2253 
2254  if( verify_string( &param1 ) != 0 ) return( 2 );
2255  if( verify_int( params[2], &param2 ) != 0 ) return( 2 );
2256  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2257 
2258  test_suite_x509_check_key_usage( param1, param2, param3 );
2259  return ( 0 );
2260  #endif /* POLARSSL_FS_IO */
2261  #endif /* POLARSSL_X509_CRT_PARSE_C */
2262  #endif /* POLARSSL_X509_CHECK_KEY_USAGE */
2263 
2264  return ( 3 );
2265  }
2266  else
2267  if( strcmp( params[0], "x509_check_extended_key_usage" ) == 0 )
2268  {
2269  #ifdef POLARSSL_FS_IO
2270  #ifdef POLARSSL_X509_CRT_PARSE_C
2271  #ifdef POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE
2272 
2273  char *param1 = params[1];
2274  char *param2 = params[2];
2275  int param3;
2276 
2277  if( cnt != 4 )
2278  {
2279  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
2280  return( 2 );
2281  }
2282 
2283  if( verify_string( &param1 ) != 0 ) return( 2 );
2284  if( verify_string( &param2 ) != 0 ) return( 2 );
2285  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2286 
2287  test_suite_x509_check_extended_key_usage( param1, param2, param3 );
2288  return ( 0 );
2289  #endif /* POLARSSL_FS_IO */
2290  #endif /* POLARSSL_X509_CRT_PARSE_C */
2291  #endif /* POLARSSL_X509_CHECK_EXTENDED_KEY_USAGE */
2292 
2293  return ( 3 );
2294  }
2295  else
2296  if( strcmp( params[0], "x509_parse_rsassa_pss_params" ) == 0 )
2297  {
2298  #ifdef POLARSSL_X509_CRT_PARSE_C
2299  #ifdef POLARSSL_X509_RSASSA_PSS_SUPPORT
2300 
2301  char *param1 = params[1];
2302  int param2;
2303  int param3;
2304  int param4;
2305  int param5;
2306  int param6;
2307 
2308  if( cnt != 7 )
2309  {
2310  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
2311  return( 2 );
2312  }
2313 
2314  if( verify_string( &param1 ) != 0 ) return( 2 );
2315  if( verify_int( params[2], &param2 ) != 0 ) return( 2 );
2316  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2317  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
2318  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
2319  if( verify_int( params[6], &param6 ) != 0 ) return( 2 );
2320 
2321  test_suite_x509_parse_rsassa_pss_params( param1, param2, param3, param4, param5, param6 );
2322  return ( 0 );
2323  #endif /* POLARSSL_X509_CRT_PARSE_C */
2324  #endif /* POLARSSL_X509_RSASSA_PSS_SUPPORT */
2325 
2326  return ( 3 );
2327  }
2328  else
2329  if( strcmp( params[0], "x509_selftest" ) == 0 )
2330  {
2331  #ifdef POLARSSL_X509_CRT_PARSE_C
2332  #ifdef POLARSSL_SELF_TEST
2333 
2334 
2335  if( cnt != 1 )
2336  {
2337  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 1 );
2338  return( 2 );
2339  }
2340 
2341 
2342  test_suite_x509_selftest( );
2343  return ( 0 );
2344  #endif /* POLARSSL_X509_CRT_PARSE_C */
2345  #endif /* POLARSSL_SELF_TEST */
2346 
2347  return ( 3 );
2348  }
2349  else
2350 
2351  {
2352  fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
2353  fflush( stdout );
2354  return( 1 );
2355  }
2356 #else
2357  return( 3 );
2358 #endif
2359  return( ret );
2360 }
2361 
2362 int get_line( FILE *f, char *buf, size_t len )
2363 {
2364  char *ret;
2365 
2366  ret = fgets( buf, len, f );
2367  if( ret == NULL )
2368  return( -1 );
2369 
2370  if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
2371  buf[strlen(buf) - 1] = '\0';
2372  if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
2373  buf[strlen(buf) - 1] = '\0';
2374 
2375  return( 0 );
2376 }
2377 
2378 int parse_arguments( char *buf, size_t len, char *params[50] )
2379 {
2380  int cnt = 0, i;
2381  char *cur = buf;
2382  char *p = buf, *q;
2383 
2384  params[cnt++] = cur;
2385 
2386  while( *p != '\0' && p < buf + len )
2387  {
2388  if( *p == '\\' )
2389  {
2390  p++;
2391  p++;
2392  continue;
2393  }
2394  if( *p == ':' )
2395  {
2396  if( p + 1 < buf + len )
2397  {
2398  cur = p + 1;
2399  params[cnt++] = cur;
2400  }
2401  *p = '\0';
2402  }
2403 
2404  p++;
2405  }
2406 
2407  // Replace newlines, question marks and colons in strings
2408  for( i = 0; i < cnt; i++ )
2409  {
2410  p = params[i];
2411  q = params[i];
2412 
2413  while( *p != '\0' )
2414  {
2415  if( *p == '\\' && *(p + 1) == 'n' )
2416  {
2417  p += 2;
2418  *(q++) = '\n';
2419  }
2420  else if( *p == '\\' && *(p + 1) == ':' )
2421  {
2422  p += 2;
2423  *(q++) = ':';
2424  }
2425  else if( *p == '\\' && *(p + 1) == '?' )
2426  {
2427  p += 2;
2428  *(q++) = '?';
2429  }
2430  else
2431  *(q++) = *(p++);
2432  }
2433  *q = '\0';
2434  }
2435 
2436  return( cnt );
2437 }
2438 
2439 int main()
2440 {
2441  int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
2442  const char *filename = "/home/iurt/rpmbuild/BUILD/polarssl-1.3.8/tests/suites/test_suite_x509parse.data";
2443  FILE *file;
2444  char buf[5000];
2445  char *params[50];
2446 
2447 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
2448  unsigned char alloc_buf[1000000];
2449  memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
2450 #endif
2451 
2452  file = fopen( filename, "r" );
2453  if( file == NULL )
2454  {
2455  fprintf( stderr, "Failed to open\n" );
2456  return( 1 );
2457  }
2458 
2459  while( !feof( file ) )
2460  {
2461  int skip = 0;
2462 
2463  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
2464  break;
2465  fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
2466  fprintf( stdout, " " );
2467  for( i = strlen( buf ) + 1; i < 67; i++ )
2468  fprintf( stdout, "." );
2469  fprintf( stdout, " " );
2470  fflush( stdout );
2471 
2472  total_tests++;
2473 
2474  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
2475  break;
2476  cnt = parse_arguments( buf, strlen(buf), params );
2477 
2478  if( strcmp( params[0], "depends_on" ) == 0 )
2479  {
2480  for( i = 1; i < cnt; i++ )
2481  if( dep_check( params[i] ) != 0 )
2482  skip = 1;
2483 
2484  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
2485  break;
2486  cnt = parse_arguments( buf, strlen(buf), params );
2487  }
2488 
2489  if( skip == 0 )
2490  {
2491  test_errors = 0;
2492  ret = dispatch_test( cnt, params );
2493  }
2494 
2495  if( skip == 1 || ret == 3 )
2496  {
2497  total_skipped++;
2498  fprintf( stdout, "----\n" );
2499  fflush( stdout );
2500  }
2501  else if( ret == 0 && test_errors == 0 )
2502  {
2503  fprintf( stdout, "PASS\n" );
2504  fflush( stdout );
2505  }
2506  else if( ret == 2 )
2507  {
2508  fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
2509  fclose(file);
2510  exit( 2 );
2511  }
2512  else
2513  total_errors++;
2514 
2515  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
2516  break;
2517  if( strlen(buf) != 0 )
2518  {
2519  fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
2520  return( 1 );
2521  }
2522  }
2523  fclose(file);
2524 
2525  fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
2526  if( total_errors == 0 )
2527  fprintf( stdout, "PASSED" );
2528  else
2529  fprintf( stdout, "FAILED" );
2530 
2531  fprintf( stdout, " (%d / %d tests (%d skipped))\n",
2532  total_tests - total_errors, total_tests, total_skipped );
2533 
2534 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
2535 #if defined(POLARSSL_MEMORY_DEBUG)
2536  memory_buffer_alloc_status();
2537 #endif
2539 #endif
2540 
2541  return( total_errors != 0 );
2542 }
2543 
2544