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 : }
|
