build: Use {CFLAGS,CPPFLAGS,LDFLAGS}_FOR_BUILD for helper program.
[libksba.git] / tests / t-cms-parser.c
1 /* t-cms-parser.c - basic test for the CMS parser.
2  *      Copyright (C) 2001 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 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <assert.h>
24 #include <time.h>
25 #include <errno.h>
26
27 #include "../src/ksba.h"
28
29 #include "t-common.h"
30
31 void
32 dummy_hash_fnc (void *arg, const void *buffer, size_t length)
33 {
34   (void)arg;
35   (void)buffer;
36   (void)length;
37 }
38
39 static int
40 dummy_writer_cb (void *cb_value, const void *buffer, size_t count)
41 {
42   (void)cb_value;
43   (void)buffer;
44   (void)count;
45   return 0;
46 }
47
48
49
50 static void
51 one_file (const char *fname)
52 {
53   gpg_error_t err;
54   FILE *fp;
55   ksba_reader_t r;
56   ksba_writer_t w;
57   ksba_cms_t cms;
58   int i;
59   const char *algoid;
60   ksba_stop_reason_t stopreason;
61   const char *s;
62   size_t n;
63   ksba_sexp_t p;
64   char *dn;
65   int idx;
66
67   printf ("*** checking `%s' ***\n", fname);
68   fp = fopen (fname, "r");
69   if (!fp)
70     {
71       fprintf (stderr, "%s:%d: can't open `%s': %s\n",
72                __FILE__, __LINE__, fname, strerror (errno));
73       exit (1);
74     }
75
76   err = ksba_reader_new (&r);
77   if (err)
78     fail_if_err (err);
79   err = ksba_reader_set_file (r, fp);
80   fail_if_err (err);
81   /* Also create a writer so that cms.c won't return an error when
82      writing processed content.  */
83   err = ksba_writer_new (&w);
84   if (err)
85     fail_if_err (err);
86   err = ksba_writer_set_cb (w, dummy_writer_cb, NULL);
87   fail_if_err (err);
88
89   switch (ksba_cms_identify (r))
90     {
91     case KSBA_CT_DATA:           s = "data"; break;
92     case KSBA_CT_SIGNED_DATA:    s = "signed data"; break;
93     case KSBA_CT_ENVELOPED_DATA: s = "enveloped data"; break;
94     case KSBA_CT_DIGESTED_DATA:  s = "digested data"; break;
95     case KSBA_CT_ENCRYPTED_DATA: s = "encrypted data"; break;
96     case KSBA_CT_AUTH_DATA:      s = "auth data"; break;
97     case KSBA_CT_SPC_IND_DATA_CTX:s = "spc indirect data context"; break;
98     default:                     s = "unknown"; break;
99     }
100   printf ("identified as: %s\n", s);
101
102   err = ksba_cms_new (&cms);
103   if (err)
104     fail_if_err (err);
105
106   err = ksba_cms_set_reader_writer (cms, r, w);
107   fail_if_err (err);
108
109   err = ksba_cms_parse (cms, &stopreason);
110   fail_if_err2 (fname, err);
111   printf ("stop reason: %d\n", stopreason);
112
113   s = ksba_cms_get_content_oid (cms, 0);
114   printf ("ContentType: %s\n", s?s:"none");
115
116   err = ksba_cms_parse (cms, &stopreason);
117   fail_if_err2 (fname, err);
118   printf ("stop reason: %d\n", stopreason);
119
120   s = ksba_cms_get_content_oid (cms, 1);
121   printf ("EncapsulatedContentType: %s\n", s?s:"none");
122   printf ("DigestAlgorithms:");
123   for (i=0; (algoid = ksba_cms_get_digest_algo_list (cms, i)); i++)
124     printf (" %s", algoid);
125   putchar('\n');
126
127   if (stopreason == KSBA_SR_NEED_HASH)
128     printf("Detached signature\n");
129
130   ksba_cms_set_hash_function (cms, dummy_hash_fnc, NULL);
131
132   do
133     {
134       err = ksba_cms_parse (cms, &stopreason);
135       fail_if_err2 (fname, err);
136       printf ("stop reason: %d\n", stopreason);
137     }
138   while (stopreason != KSBA_SR_READY);
139
140
141   if (ksba_cms_get_content_type (cms, 0) == KSBA_CT_ENVELOPED_DATA)
142     {
143       for (idx=0; ; idx++)
144         {
145           err = ksba_cms_get_issuer_serial (cms, idx, &dn, &p);
146           if (err == -1)
147             break; /* ready */
148
149           fail_if_err2 (fname, err);
150           printf ("recipient %d - issuer: ", idx);
151           print_dn (dn);
152           ksba_free (dn);
153           putchar ('\n');
154           printf ("recipient %d - serial: ", idx);
155           print_sexp_hex (p);
156           ksba_free (p);
157           putchar ('\n');
158
159           dn = ksba_cms_get_enc_val (cms, idx);
160           printf ("recipient %d - enc_val %s\n", idx, dn? "found": "missing");
161           ksba_free (dn);
162         }
163     }
164   else
165     {
166       for (idx=0; idx < 1; idx++)
167         {
168           err = ksba_cms_get_issuer_serial (cms, idx, &dn, &p);
169           if (gpg_err_code (err) == GPG_ERR_NO_DATA && !idx)
170             {
171               printf ("this is a certs-only message\n");
172               break;
173             }
174
175           fail_if_err2 (fname, err);
176           printf ("signer %d - issuer: ", idx);
177           print_dn (dn);
178           ksba_free (dn);
179           putchar ('\n');
180           printf ("signer %d - serial: ", idx);
181           print_sexp_hex (p);
182           ksba_free (p);
183           putchar ('\n');
184
185           err = ksba_cms_get_message_digest (cms, idx, &dn, &n);
186           fail_if_err2 (fname, err);
187           printf ("signer %d - messageDigest: ", idx);
188           print_hex (dn, n);
189           ksba_free (dn);
190           putchar ('\n');
191
192           err = ksba_cms_get_sigattr_oids (cms, idx,
193                                            "1.2.840.113549.1.9.3",&dn);
194           if (err && err != -1)
195             fail_if_err2 (fname, err);
196           if (err != -1)
197             {
198               char *tmp;
199
200               for (tmp=dn; *tmp; tmp++)
201                 if (*tmp == '\n')
202                   *tmp = ' ';
203               printf ("signer %d - content-type: %s\n", idx, dn);
204               ksba_free (dn);
205             }
206
207           algoid = ksba_cms_get_digest_algo (cms, idx);
208           printf ("signer %d - digest algo: %s\n", idx, algoid?algoid:"?");
209
210           dn = ksba_cms_get_sig_val (cms, idx);
211           if (dn)
212             {
213               printf ("signer %d - signature: ", idx);
214               print_sexp (dn);
215               putchar ('\n');
216             }
217           else
218             printf ("signer %d - signature not found\n", idx);
219           ksba_free (dn);
220         }
221     }
222
223   ksba_cms_release (cms);
224   ksba_writer_release (w);
225   ksba_reader_release (r);
226   fclose (fp);
227 }
228
229
230
231
232 int
233 main (int argc, char **argv)
234 {
235   if (argc > 1)
236     one_file (argv[1]);
237   else
238     {
239       char *fname = prepend_srcdir ("detached-sig.cms");
240
241       one_file (fname);
242       free(fname);
243     }
244   /*one_file ("pkcs7-1.ber");*/
245   /*one_file ("root-cert-2.der");  should fail */
246
247   return 0;
248 }