LCOV - code coverage report
Current view: top level - tests - t-crl-parser.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 109 142 76.8 %
Date: 2016-09-12 12:51:24 Functions: 4 5 80.0 %

          Line data    Source code
       1             : /* t-crl-parser.c - basic test for the CRl parser.
       2             :  *      Copyright (C) 2002, 2004, 2005 g10 Code GmbH
       3             :  *
       4             :  * This file is part of KSBA.
       5             :  *
       6             :  * KSBA is free software; you can redistribute it and/or modify
       7             :  * it under the terms of the GNU General Public License as published by
       8             :  * the Free Software Foundation; either version 3 of the License, or
       9             :  * (at your option) any later version.
      10             :  *
      11             :  * KSBA is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             :  * GNU General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU General Public License
      17             :  * along with this program; if not, see <http://www.gnu.org/licenses/>.
      18             :  */
      19             : 
      20             : #undef ENABLE_HASH_LOGGING
      21             : 
      22             : #ifdef ENABLE_HASH_LOGGING
      23             : #define _GNU_SOURCE 1
      24             : #endif
      25             : #include <stdio.h>
      26             : #include <stdlib.h>
      27             : #include <string.h>
      28             : #include <assert.h>
      29             : #include <time.h>
      30             : #include <errno.h>
      31             : 
      32             : #include "../src/ksba.h"
      33             : 
      34             : #include "t-common.h"
      35             : #include "oidtranstbl.h"
      36             : 
      37             : static void
      38           0 : my_hasher (void *arg, const void *buffer, size_t length)
      39             : {
      40           0 :   FILE *fp = arg;
      41             : 
      42           0 :   if (fp)
      43             :     {
      44           0 :       if ( fwrite (buffer, length, 1, fp) != 1 )
      45           0 :         fail ("error writing to-be-hashed data");
      46             :     }
      47           0 : }
      48             : 
      49             : 
      50             : /* Return the description for OID; if no description is available
      51             :    NULL is returned. */
      52             : static const char *
      53           3 : get_oid_desc (const char *oid)
      54             : {
      55             :   int i;
      56             : 
      57           3 :   if (oid)
      58           3 :     for (i=0; oidtranstbl[i].oid; i++)
      59           0 :       if (!strcmp (oidtranstbl[i].oid, oid))
      60           0 :         return oidtranstbl[i].desc;
      61           3 :   return NULL;
      62             : }
      63             : 
      64             : 
      65             : static void
      66           1 : print_names (int indent, ksba_name_t name)
      67             : {
      68             :   int idx;
      69             :   const char *s;
      70             :   int indent_all;
      71             : 
      72           1 :   if ((indent_all = (indent < 0)))
      73           0 :     indent = - indent;
      74             : 
      75           1 :   if (!name)
      76             :     {
      77           0 :       fputs ("none\n", stdout);
      78           1 :       return;
      79             :     }
      80             : 
      81           2 :   for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
      82             :     {
      83           1 :       char *p = ksba_name_get_uri (name, idx);
      84           1 :       printf ("%*s%s\n", idx||indent_all?indent:0, "", p?p:s);
      85           1 :       xfree (p);
      86             :     }
      87             : }
      88             : 
      89             : 
      90             : 
      91             : static void
      92           1 : one_file (const char *fname)
      93             : {
      94             :   gpg_error_t err;
      95             :   FILE *fp;
      96             :   ksba_reader_t r;
      97             :   ksba_crl_t crl;
      98             :   ksba_stop_reason_t stopreason;
      99           1 :   int count = 0;
     100           1 :   FILE *hashlog = NULL;
     101             : 
     102             : #ifdef ENABLE_HASH_LOGGING
     103             :     {
     104             :       char *buf;
     105             : 
     106             :       if (asprintf (&buf, "%s.hash.log", fname) < 0)
     107             :         fail ("asprintf failed");
     108             :       hashlog = fopen (buf, "wb");
     109             :       if (!hashlog)
     110             :         fail ("can't create log file");
     111             :       free (buf);
     112             :     }
     113             : #endif
     114             : 
     115           1 :   printf ("*** checking `%s' ***\n", fname);
     116           1 :   fp = fopen (fname, "r");
     117           1 :   if (!fp)
     118             :     {
     119           0 :       fprintf (stderr, "%s:%d: can't open `%s': %s\n",
     120           0 :                __FILE__, __LINE__, fname, strerror (errno));
     121           0 :       exit (1);
     122             :     }
     123             : 
     124           1 :   err = ksba_reader_new (&r);
     125           1 :   if (err)
     126           0 :     fail_if_err (err);
     127           1 :   err = ksba_reader_set_file (r, fp);
     128           1 :   fail_if_err (err);
     129             : 
     130           1 :   err = ksba_crl_new (&crl);
     131           1 :   if (err)
     132           0 :     fail_if_err (err);
     133             : 
     134           1 :   err = ksba_crl_set_reader (crl, r);
     135           1 :   fail_if_err (err);
     136             : 
     137           1 :   if (hashlog)
     138           0 :     ksba_crl_set_hash_function (crl, my_hasher, hashlog);
     139             : 
     140             :   do
     141             :     {
     142          13 :       err = ksba_crl_parse (crl, &stopreason);
     143          13 :       fail_if_err2 (fname, err);
     144          13 :       switch (stopreason)
     145             :         {
     146             :         case KSBA_SR_BEGIN_ITEMS:
     147             :           {
     148             :             const char *algoid;
     149             :             char *issuer;
     150             :             ksba_isotime_t this, next;
     151             : 
     152           1 :             algoid = ksba_crl_get_digest_algo (crl);
     153           1 :             printf ("digest algo: %s\n", algoid? algoid : "[none]");
     154             : 
     155           1 :             err = ksba_crl_get_issuer (crl, &issuer);
     156           1 :             fail_if_err2 (fname, err);
     157           1 :             printf ("issuer: ");
     158           1 :             print_dn (issuer);
     159           1 :             xfree (issuer);
     160           1 :             putchar ('\n');
     161           1 :             err = ksba_crl_get_update_times (crl, this, next);
     162           1 :             if (gpg_err_code (err) != GPG_ERR_INV_TIME)
     163           1 :               fail_if_err2 (fname, err);
     164           1 :             printf ("thisUpdate: ");
     165           1 :             print_time (this);
     166           1 :             putchar ('\n');
     167           1 :             printf ("nextUpdate: ");
     168           1 :             print_time (next);
     169           1 :             putchar ('\n');
     170             :           }
     171           1 :           break;
     172             : 
     173             :         case KSBA_SR_GOT_ITEM:
     174             :           {
     175             :             ksba_sexp_t serial;
     176             :             ksba_isotime_t rdate;
     177             :             ksba_crl_reason_t reason;
     178             : 
     179          10 :             err = ksba_crl_get_item (crl, &serial, rdate, &reason);
     180          10 :             fail_if_err2 (fname, err);
     181          10 :             printf ("CRL entry %d: s=", ++count);
     182          10 :             print_sexp_hex (serial);
     183          10 :             printf (", t=");
     184          10 :             print_time (rdate);
     185          10 :             printf (", r=%x\n", reason);
     186          10 :             xfree (serial);
     187             :           }
     188          10 :           break;
     189             : 
     190             :         case KSBA_SR_END_ITEMS:
     191           1 :           break;
     192             : 
     193             :         case KSBA_SR_READY:
     194           1 :           break;
     195             : 
     196             :         default:
     197           0 :           fail ("unknown stop reason");
     198             :         }
     199             : 
     200             :     }
     201          13 :   while (stopreason != KSBA_SR_READY);
     202             : 
     203           1 :   if ( !ksba_crl_get_digest_algo (crl))
     204           0 :     fail ("digest algorithm mismatch");
     205             : 
     206             :   {
     207             :     ksba_name_t name1;
     208             :     ksba_sexp_t serial;
     209             :     ksba_sexp_t keyid;
     210             : 
     211           1 :     err = ksba_crl_get_auth_key_id (crl, &keyid, &name1, &serial);
     212           1 :     if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
     213             :       {
     214           1 :         fputs ("AuthorityKeyIdentifier: ", stdout);
     215           2 :         if (gpg_err_code (err) == GPG_ERR_NO_DATA)
     216           0 :           fputs ("none\n", stdout);
     217             :         else
     218             :           {
     219           1 :             if (name1)
     220             :               {
     221           1 :                 print_names (24, name1);
     222           1 :                 ksba_name_release (name1);
     223           1 :                 fputs ("                serial: ", stdout);
     224           1 :                 print_sexp_hex (serial);
     225           1 :                 ksba_free (serial);
     226             :               }
     227           1 :             putchar ('\n');
     228           1 :             if (keyid)
     229             :               {
     230           0 :                 fputs ("         keyIdentifier: ", stdout);
     231           0 :                 print_sexp (keyid);
     232           0 :                 ksba_free (keyid);
     233           0 :                 putchar ('\n');
     234             :               }
     235             :           }
     236             :       }
     237             :     else
     238           0 :       fail_if_err (err);
     239             :   }
     240             : 
     241             :   {
     242             :     ksba_sexp_t serial;
     243             : 
     244           1 :     err = ksba_crl_get_crl_number (crl, &serial);
     245           1 :     if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
     246             :       {
     247           1 :         fputs ("crlNumber: ", stdout);
     248           1 :         if (gpg_err_code (err) == GPG_ERR_NO_DATA)
     249           0 :           fputs ("none", stdout);
     250             :         else
     251             :           {
     252           1 :             print_sexp (serial);
     253           1 :             ksba_free (serial);
     254             :           }
     255           1 :         putchar ('\n');
     256             :       }
     257             :     else
     258           0 :       fail_if_err (err);
     259             :   }
     260             : 
     261             : 
     262             :   {
     263             :     int idx, crit;
     264             :     const char *oid;
     265             :     size_t derlen;
     266             : 
     267           5 :     for (idx=0; !(err=ksba_crl_get_extension (crl, idx,
     268             :                                               &oid, &crit,
     269           3 :                                               NULL, &derlen)); idx++)
     270             :       {
     271           3 :         const char *s = get_oid_desc (oid);
     272           6 :         printf ("%sExtn: %s%s%s%s   (%lu octets)\n",
     273           3 :                 crit? "Crit":"",
     274             :                 s?" (":"", s?s:"", s?")":"",
     275             :                 oid, (unsigned long)derlen);
     276             :       }
     277           1 :     if (err && gpg_err_code (err) != GPG_ERR_EOF
     278           0 :         && gpg_err_code (err) != GPG_ERR_NO_DATA )
     279           0 :       fail_if_err (err);
     280             :   }
     281             : 
     282             : 
     283             :   {
     284             :     ksba_sexp_t sigval;
     285             : 
     286           1 :     sigval = ksba_crl_get_sig_val (crl);
     287           1 :     if (!sigval)
     288           0 :       fail ("signature value missing");
     289           1 :     print_sexp (sigval);
     290           1 :     putchar ('\n');
     291           1 :     xfree (sigval);
     292             :   }
     293             : 
     294             : 
     295           1 :   ksba_crl_release (crl);
     296           1 :   ksba_reader_release (r);
     297           1 :   fclose (fp);
     298           1 :   if (hashlog)
     299           0 :     fclose (hashlog);
     300           1 : }
     301             : 
     302             : 
     303             : 
     304             : 
     305             : int
     306           1 : main (int argc, char **argv)
     307             : {
     308           1 :   const char *srcdir = getenv ("srcdir");
     309             : 
     310           1 :   if (!srcdir)
     311           0 :     srcdir = ".";
     312             : 
     313           1 :   if (argc > 1)
     314             :     {
     315           0 :       for (argc--, argv++; argc; argc--, argv++)
     316           0 :         one_file (*argv);
     317             :     }
     318             :   else
     319             :     {
     320           1 :       const char *files[] = {
     321             :         "crl_testpki_testpca.der",
     322             :         NULL
     323             :       };
     324             :       int idx;
     325             : 
     326           2 :       for (idx=0; files[idx]; idx++)
     327             :         {
     328             :           char *fname;
     329             : 
     330           1 :           fname = xmalloc (strlen (srcdir) + 1 + strlen (files[idx]) + 1);
     331           1 :           strcpy (fname, srcdir);
     332           1 :           strcat (fname, "/");
     333           1 :           strcat (fname, files[idx]);
     334           1 :           one_file (fname);
     335           1 :           xfree (fname);
     336             :         }
     337             :     }
     338             : 
     339           1 :   return 0;
     340             : }

Generated by: LCOV version 1.11