2002-02-25 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / verify.c
1 /* verify.c -  signature verification
2  *      Copyright (C) 2000 Werner Koch (dd9jn)
3  *      Copyright (C) 2001, 2002 g10 Code GmbH
4  *
5  * This file is part of GPGME.
6  *
7  * GPGME is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GPGME is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "util.h"
29 #include "context.h"
30 #include "ops.h"
31 #include "key.h"
32
33
34 struct verify_result_s
35 {
36   struct verify_result_s *next;
37   GpgmeSigStat status;
38   GpgmeData notation;   /* We store an XML fragment here.  */
39   int collecting;       /* Private to finish_sig().  */
40   int notation_in_data; /* Private to add_notation().  */
41   char fpr[41];         /* Fingerprint of a good signature or keyid of
42                            a bad one.  */
43   ulong timestamp;      /* Signature creation time.  */
44 };
45
46
47 void
48 _gpgme_release_verify_result (VerifyResult result)
49 {
50   while (result)
51     {
52       VerifyResult next_result = result->next;
53       gpgme_data_release (result->notation);
54       xfree (result);
55       result = next_result;
56     }
57 }
58
59
60 /* FIXME: Check that we are adding this to the correct signature.  */
61 static void
62 add_notation (GpgmeCtx ctx, GpgStatusCode code, const char *data)
63 {
64   GpgmeData dh = ctx->result.verify->notation;
65
66   if (!dh)
67     {
68       if (gpgme_data_new (&dh))
69         {
70           ctx->error = mk_error (Out_Of_Core);
71           return;
72         }
73       ctx->result.verify->notation = dh;
74       _gpgme_data_append_string (dh, "  <notation>\n");
75     }
76
77   if (code == STATUS_NOTATION_DATA)
78     {
79       if (!ctx->result.verify->notation_in_data)
80         _gpgme_data_append_string (dh, "  <data>");
81       _gpgme_data_append_percentstring_for_xml (dh, data);
82       ctx->result.verify->notation_in_data = 1;
83       return;
84     }
85
86   if (ctx->result.verify->notation_in_data)
87     {
88       _gpgme_data_append_string (dh, "</data>\n");
89       ctx->result.verify->notation_in_data = 0;
90     }
91
92   if (code == STATUS_NOTATION_NAME)
93     {
94       _gpgme_data_append_string (dh, "  <name>");
95       _gpgme_data_append_percentstring_for_xml (dh, data);
96       _gpgme_data_append_string (dh, "</name>\n");
97     }
98   else if (code == STATUS_POLICY_URL)
99     {
100       _gpgme_data_append_string (dh, "  <policy>");
101       _gpgme_data_append_percentstring_for_xml (dh, data);
102       _gpgme_data_append_string (dh, "</policy>\n");
103     }
104   else
105     assert (0);
106 }
107
108
109 /* 
110  * finish a pending signature info collection and prepare for a new
111  * signature info collection
112  */
113 static void
114 finish_sig (GpgmeCtx ctx, int stop)
115 {
116   if (stop)
117     return; /* nothing to do */
118
119   if (ctx->result.verify->collecting)
120     {
121       VerifyResult res2;
122
123       ctx->result.verify->collecting = 0;
124       /* Create a new result structure.  */
125       res2 = xtrycalloc (1, sizeof *res2);
126       if (!res2)
127         {
128           ctx->error = mk_error (Out_Of_Core);
129           return;
130         }
131
132       res2->next = ctx->result.verify;
133       ctx->result.verify = res2;
134     }
135     
136   ctx->result.verify->collecting = 1;
137 }
138
139
140 void
141 _gpgme_verify_status_handler (GpgmeCtx ctx, GpgStatusCode code, char *args)
142 {
143   char *p;
144   int i;
145
146   if (ctx->error)
147     return;
148   test_and_allocate_result (ctx, verify);
149
150   if (code == STATUS_GOODSIG || code == STATUS_BADSIG || code == STATUS_ERRSIG)
151     {
152       finish_sig (ctx,0);
153       if (ctx->error)
154         return;
155     }
156
157   switch (code)
158     {
159     case STATUS_NODATA:
160       ctx->result.verify->status = GPGME_SIG_STAT_NOSIG;
161       break;
162
163     case STATUS_GOODSIG:
164       /* We only look at VALIDSIG */
165       break;
166
167     case STATUS_VALIDSIG:
168       ctx->result.verify->status = GPGME_SIG_STAT_GOOD;
169       p = ctx->result.verify->fpr;
170       for (i = 0; i < DIM(ctx->result.verify->fpr)
171              && args[i] && args[i] != ' ' ; i++)
172         *p++ = args[i];
173       *p = 0;
174       /* Skip the formatted date.  */
175       while (args[i] && args[i] == ' ')
176         i++;
177       while (args[i] && args[i] != ' ')
178         i++;
179       /* And get the timestamp.  */
180       ctx->result.verify->timestamp = strtoul (args+i, NULL, 10);
181       break;
182
183     case STATUS_BADSIG:
184       ctx->result.verify->status = GPGME_SIG_STAT_BAD;
185       /* Store the keyID in the fpr field.  */
186       p = ctx->result.verify->fpr;
187       for (i = 0; i < DIM(ctx->result.verify->fpr)
188              && args[i] && args[i] != ' ' ; i++)
189         *p++ = args[i];
190       *p = 0;
191       break;
192
193     case STATUS_ERRSIG:
194       /* The return code is the 6th argument, if it is 9, the problem
195          is a missing key.  */
196       for (p = args, i = 0; p && i < 5; i++)
197         p = strchr (p, ' ');
198       if (p && *(++p) == '9' && *(++p) == '\0')
199         ctx->result.verify->status = GPGME_SIG_STAT_NOKEY;
200       else
201         ctx->result.verify->status = GPGME_SIG_STAT_ERROR;
202       /* Store the keyID in the fpr field.  */
203       p = ctx->result.verify->fpr;
204       for (i = 0; i < DIM(ctx->result.verify->fpr)
205              && args[i] && args[i] != ' ' ; i++)
206         *p++ = args[i];
207       *p = 0;
208       break;
209
210     case STATUS_NOTATION_NAME:
211     case STATUS_NOTATION_DATA:
212     case STATUS_POLICY_URL:
213       add_notation (ctx, code, args);
214       break;
215
216     case STATUS_END_STREAM:
217       break;
218
219     case STATUS_EOF:
220       finish_sig (ctx,1);
221
222       /* FIXME: Put all notation data into one XML fragment.  */
223       if (ctx->result.verify->notation)
224         {
225           GpgmeData dh = ctx->result.verify->notation;
226
227           if (ctx->result.verify->notation_in_data)
228             {
229               _gpgme_data_append_string (dh, "</data>\n");
230               ctx->result.verify->notation_in_data = 0;
231             }
232           _gpgme_data_append_string (dh, "</notation>\n");
233           ctx->notation = dh;
234           ctx->result.verify->notation = NULL;
235         }
236       break;
237  
238     default:
239       /* Ignore all other codes.  */
240       break;
241     }
242 }
243
244 GpgmeError
245 gpgme_op_verify_start (GpgmeCtx ctx, GpgmeData sig, GpgmeData text)
246 {
247   int err = 0;
248   int pipemode = 0;      /* !!text; use pipemode for detached sigs.  */
249
250   fail_on_pending_request (ctx);
251   ctx->pending = 1;
252
253   _gpgme_release_result (ctx);
254     
255   if (!pipemode)
256     {
257       _gpgme_engine_release (ctx->engine);
258       ctx->engine = NULL;
259     }
260
261   if (!ctx->engine)
262     err = _gpgme_engine_new (ctx->use_cms ? GPGME_PROTOCOL_CMS
263                              : GPGME_PROTOCOL_OpenPGP, &ctx->engine);
264   if (err)
265     goto leave;
266
267 #if 0   /* FIXME */
268   if (pipemode)
269     _gpgme_gpg_enable_pipemode (c->engine->engine.gpg);
270 #endif
271
272   _gpgme_engine_set_status_handler (ctx->engine, _gpgme_verify_status_handler,
273                                     ctx);
274   _gpgme_engine_set_verbosity (ctx->engine, ctx->verbosity);
275
276   /* Check the supplied data.  */
277   if (gpgme_data_get_type (sig) == GPGME_DATA_TYPE_NONE)
278     {
279       err = mk_error (No_Data);
280       goto leave;
281     }
282   if (text && gpgme_data_get_type (text) == GPGME_DATA_TYPE_NONE)
283     {
284       err = mk_error (No_Data);
285       goto leave;
286     }
287   _gpgme_data_set_mode (sig, GPGME_DATA_MODE_OUT);
288   if (text)         /* Detached signature.  */
289     _gpgme_data_set_mode (text, GPGME_DATA_MODE_OUT);
290
291   err = _gpgme_engine_op_verify (ctx->engine, sig, text);
292   if (!err)     /* And kick off the process.  */
293     err = _gpgme_engine_start (ctx->engine, ctx);
294
295  leave:
296   if (err)
297     {
298       ctx->pending = 0; 
299       _gpgme_engine_release (ctx->engine);
300       ctx->engine = NULL;
301     }
302   return err;
303 }
304
305 /* 
306  * Figure out a common status value for all signatures 
307  */
308 GpgmeSigStat
309 _gpgme_intersect_stati (VerifyResult result)
310 {
311   GpgmeSigStat status = result->status;
312
313   for (result = result->next; result; result = result->next)
314     {
315       if (status != result->status) 
316         return GPGME_SIG_STAT_DIFF;
317     }
318   return status;
319 }
320
321 /**
322  * gpgme_op_verify:
323  * @c: the context
324  * @sig: the signature data
325  * @text: the signed text
326  * @r_stat: returns the status of the signature
327  * 
328  * Perform a signature check on the signature given in @sig. Currently it is
329  * assumed that this is a detached signature for the material given in @text.
330  * The result of this operation is returned in @r_stat which can take these
331  * values:
332  *  GPGME_SIG_STAT_NONE:  No status - should not happen
333  *  GPGME_SIG_STAT_GOOD:  The signature is valid 
334  *  GPGME_SIG_STAT_BAD:   The signature is not valid
335  *  GPGME_SIG_STAT_NOKEY: The signature could not be checked due to a
336  *                        missing key
337  *  GPGME_SIG_STAT_NOSIG: This is not a signature
338  *  GPGME_SIG_STAT_ERROR: Due to some other error the check could not be done.
339  *  GPGME_SIG_STAT_DIFF:  There is more than 1 signature and they have not
340  *                        the same status.
341  *
342  * Return value: 0 on success or an errorcode if something not related to
343  *               the signature itself did go wrong.
344  **/
345 GpgmeError
346 gpgme_op_verify (GpgmeCtx ctx, GpgmeData sig, GpgmeData text,
347                  GpgmeSigStat *r_stat)
348 {
349   GpgmeError err;
350
351   if (!r_stat)
352     return mk_error (Invalid_Value);
353
354   gpgme_data_release (ctx->notation);
355   ctx->notation = NULL;
356     
357   *r_stat = GPGME_SIG_STAT_NONE;
358   err = gpgme_op_verify_start (ctx, sig, text);
359   if (!err)
360     {
361       gpgme_wait (ctx, &err, 1);
362       if (!err)
363         *r_stat = _gpgme_intersect_stati (ctx->result.verify);
364     }
365     return err;
366 }
367
368
369 /**
370  * gpgme_get_sig_status:
371  * @c: Context
372  * @idx: Index of the signature starting at 0
373  * @r_stat: Returns the status
374  * @r_created: Returns the creation timestamp
375  * 
376  * Return information about an already verified signatures. 
377  * 
378  * Return value: The fingerprint or NULL in case of an problem or
379  *               when there are no more signatures.
380  **/
381 const char *
382 gpgme_get_sig_status (GpgmeCtx c, int idx,
383                       GpgmeSigStat *r_stat, time_t *r_created)
384 {
385   VerifyResult result;
386
387   if (!c || c->pending || !c->result.verify)
388     return NULL;        /* No results yet or verification error.  */
389
390   for (result = c->result.verify;
391        result && idx > 0; result = result->next, idx--)
392     ;
393   if (!result)
394     return NULL;        /* No more signatures.  */
395
396   if (r_stat)
397     *r_stat = result->status;
398   if (r_created)
399     *r_created = result->timestamp;
400   return result->fpr;
401 }
402
403
404 /**
405  * gpgme_get_sig_key:
406  * @c: context
407  * @idx: Index of the signature starting at 0
408  * @r_key: Returns the key object
409  * 
410  * Return a key object which was used to check the signature. 
411  * 
412  * Return value: An Errorcode or 0 for success. GPGME_EOF is returned to
413  *               indicate that there are no more signatures. 
414  **/
415 GpgmeError
416 gpgme_get_sig_key (GpgmeCtx c, int idx, GpgmeKey *r_key)
417 {
418   VerifyResult result;
419   GpgmeError err = 0;
420
421   if (!c || !r_key)
422     return mk_error (Invalid_Value);
423   if (c->pending || !c->result.verify)
424     return mk_error (Busy);
425   
426   for (result = c->result.verify;
427        result && idx > 0; result = result->next, idx--)
428     ;
429   if (!result)
430     return mk_error (EOF);
431   
432   if (strlen(result->fpr) < 16) /* We have at least a key ID.  */
433     return mk_error (Invalid_Key);
434   
435   *r_key = _gpgme_key_cache_get (result->fpr);
436   if (!*r_key)
437     {
438       GpgmeCtx listctx;
439       
440       /* Fixme: This can be optimized by keeping an internal context
441          used for such key listings.  */
442       err = gpgme_new (&listctx);
443       if (err)
444         return err;
445       gpgme_set_keylist_mode (listctx, c->keylist_mode);
446       err = gpgme_op_keylist_start (listctx, result->fpr, 0);
447       if (!err)
448         err = gpgme_op_keylist_next (listctx, r_key);
449       gpgme_release (listctx);
450     }
451   return err;
452 }