doc/
[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 && *p && i < 5; i++)
197         {
198           p = strchr (p, ' ');
199           if (p)
200             while (*p == ' ')
201               p++;
202         }
203       if (p && *(p++) == '9' && (*p == '\0' || *p == ' '))
204         ctx->result.verify->status = GPGME_SIG_STAT_NOKEY;
205       else
206         ctx->result.verify->status = GPGME_SIG_STAT_ERROR;
207       /* Store the keyID in the fpr field.  */
208       p = ctx->result.verify->fpr;
209       for (i = 0; i < DIM(ctx->result.verify->fpr)
210              && args[i] && args[i] != ' ' ; i++)
211         *p++ = args[i];
212       *p = 0;
213       break;
214
215     case STATUS_NOTATION_NAME:
216     case STATUS_NOTATION_DATA:
217     case STATUS_POLICY_URL:
218       add_notation (ctx, code, args);
219       break;
220
221     case STATUS_END_STREAM:
222       break;
223
224     case STATUS_EOF:
225       finish_sig (ctx,1);
226
227       /* FIXME: Put all notation data into one XML fragment.  */
228       if (ctx->result.verify->notation)
229         {
230           GpgmeData dh = ctx->result.verify->notation;
231
232           if (ctx->result.verify->notation_in_data)
233             {
234               _gpgme_data_append_string (dh, "</data>\n");
235               ctx->result.verify->notation_in_data = 0;
236             }
237           _gpgme_data_append_string (dh, "</notation>\n");
238           ctx->notation = dh;
239           ctx->result.verify->notation = NULL;
240         }
241       break;
242  
243     default:
244       /* Ignore all other codes.  */
245       break;
246     }
247 }
248
249 GpgmeError
250 gpgme_op_verify_start (GpgmeCtx ctx, GpgmeData sig, GpgmeData text)
251 {
252   int err = 0;
253   int pipemode = 0;      /* !!text; use pipemode for detached sigs.  */
254
255   fail_on_pending_request (ctx);
256   ctx->pending = 1;
257
258   _gpgme_release_result (ctx);
259     
260   if (!pipemode)
261     {
262       _gpgme_engine_release (ctx->engine);
263       ctx->engine = NULL;
264     }
265
266   if (!ctx->engine)
267     err = _gpgme_engine_new (ctx->use_cms ? GPGME_PROTOCOL_CMS
268                              : GPGME_PROTOCOL_OpenPGP, &ctx->engine);
269   if (err)
270     goto leave;
271
272 #if 0   /* FIXME */
273   if (pipemode)
274     _gpgme_gpg_enable_pipemode (c->engine->engine.gpg);
275 #endif
276
277   _gpgme_engine_set_status_handler (ctx->engine, _gpgme_verify_status_handler,
278                                     ctx);
279   _gpgme_engine_set_verbosity (ctx->engine, ctx->verbosity);
280
281   /* Check the supplied data.  */
282   if (gpgme_data_get_type (sig) == GPGME_DATA_TYPE_NONE)
283     {
284       err = mk_error (No_Data);
285       goto leave;
286     }
287   if (!text)
288     {
289       err = mk_error (Invalid_Value);
290       goto leave;
291     }
292   _gpgme_data_set_mode (sig, GPGME_DATA_MODE_OUT);
293   if (gpgme_data_get_type (text) == GPGME_DATA_TYPE_NONE)
294     /* Normal or cleartext signature.  */
295     _gpgme_data_set_mode (text, GPGME_DATA_MODE_IN);
296   else
297     /* Detached signature.  */
298     _gpgme_data_set_mode (text, GPGME_DATA_MODE_OUT);
299
300   err = _gpgme_engine_op_verify (ctx->engine, sig, text);
301   if (!err)     /* And kick off the process.  */
302     err = _gpgme_engine_start (ctx->engine, ctx);
303
304  leave:
305   if (err)
306     {
307       ctx->pending = 0; 
308       _gpgme_engine_release (ctx->engine);
309       ctx->engine = NULL;
310     }
311   return err;
312 }
313
314 /* 
315  * Figure out a common status value for all signatures 
316  */
317 GpgmeSigStat
318 _gpgme_intersect_stati (VerifyResult result)
319 {
320   GpgmeSigStat status = result->status;
321
322   for (result = result->next; result; result = result->next)
323     {
324       if (status != result->status) 
325         return GPGME_SIG_STAT_DIFF;
326     }
327   return status;
328 }
329
330 /**
331  * gpgme_op_verify:
332  * @c: the context
333  * @sig: the signature data
334  * @text: the signed text
335  * @r_stat: returns the status of the signature
336  * 
337  * Perform a signature check on the signature given in @sig.  If @text
338  * is a new and uninitialized data object, it is assumed that @sig
339  * contains a normal or cleartext signature, and the plaintext is
340  * returned in @text upon successful verification.
341  *
342  * If @text is initialized, it is assumed that @sig is a detached
343  * signature for the material given in @text.
344  *
345  * The result of this operation is returned in @r_stat which can take these
346  * values:
347  *  GPGME_SIG_STAT_NONE:  No status - should not happen
348  *  GPGME_SIG_STAT_GOOD:  The signature is valid 
349  *  GPGME_SIG_STAT_BAD:   The signature is not valid
350  *  GPGME_SIG_STAT_NOKEY: The signature could not be checked due to a
351  *                        missing key
352  *  GPGME_SIG_STAT_NOSIG: This is not a signature
353  *  GPGME_SIG_STAT_ERROR: Due to some other error the check could not be done.
354  *  GPGME_SIG_STAT_DIFF:  There is more than 1 signature and they have not
355  *                        the same status.
356  *
357  * Return value: 0 on success or an errorcode if something not related to
358  *               the signature itself did go wrong.
359  **/
360 GpgmeError
361 gpgme_op_verify (GpgmeCtx ctx, GpgmeData sig, GpgmeData text,
362                  GpgmeSigStat *r_stat)
363 {
364   GpgmeError err;
365
366   if (!r_stat)
367     return mk_error (Invalid_Value);
368
369   gpgme_data_release (ctx->notation);
370   ctx->notation = NULL;
371     
372   *r_stat = GPGME_SIG_STAT_NONE;
373   err = gpgme_op_verify_start (ctx, sig, text);
374   if (!err)
375     {
376       gpgme_wait (ctx, &err, 1);
377       if (!err)
378         *r_stat = _gpgme_intersect_stati (ctx->result.verify);
379     }
380     return err;
381 }
382
383
384 /**
385  * gpgme_get_sig_status:
386  * @c: Context
387  * @idx: Index of the signature starting at 0
388  * @r_stat: Returns the status
389  * @r_created: Returns the creation timestamp
390  * 
391  * Return information about an already verified signatures. 
392  * 
393  * Return value: The fingerprint or NULL in case of an problem or
394  *               when there are no more signatures.
395  **/
396 const char *
397 gpgme_get_sig_status (GpgmeCtx c, int idx,
398                       GpgmeSigStat *r_stat, time_t *r_created)
399 {
400   VerifyResult result;
401
402   if (!c || c->pending || !c->result.verify)
403     return NULL;        /* No results yet or verification error.  */
404
405   for (result = c->result.verify;
406        result && idx > 0; result = result->next, idx--)
407     ;
408   if (!result)
409     return NULL;        /* No more signatures.  */
410
411   if (r_stat)
412     *r_stat = result->status;
413   if (r_created)
414     *r_created = result->timestamp;
415   return result->fpr;
416 }
417
418
419 /**
420  * gpgme_get_sig_key:
421  * @c: context
422  * @idx: Index of the signature starting at 0
423  * @r_key: Returns the key object
424  * 
425  * Return a key object which was used to check the signature. 
426  * 
427  * Return value: An Errorcode or 0 for success. GPGME_EOF is returned to
428  *               indicate that there are no more signatures. 
429  **/
430 GpgmeError
431 gpgme_get_sig_key (GpgmeCtx c, int idx, GpgmeKey *r_key)
432 {
433   VerifyResult result;
434   GpgmeError err = 0;
435
436   if (!c || !r_key)
437     return mk_error (Invalid_Value);
438   if (c->pending || !c->result.verify)
439     return mk_error (Busy);
440   
441   for (result = c->result.verify;
442        result && idx > 0; result = result->next, idx--)
443     ;
444   if (!result)
445     return mk_error (EOF);
446   
447   if (strlen(result->fpr) < 16) /* We have at least a key ID.  */
448     return mk_error (Invalid_Key);
449   
450   *r_key = _gpgme_key_cache_get (result->fpr);
451   if (!*r_key)
452     {
453       GpgmeCtx listctx;
454       
455       /* Fixme: This can be optimized by keeping an internal context
456          used for such key listings.  */
457       err = gpgme_new (&listctx);
458       if (err)
459         return err;
460       gpgme_set_keylist_mode (listctx, c->keylist_mode);
461       err = gpgme_op_keylist_start (listctx, result->fpr, 0);
462       if (!err)
463         err = gpgme_op_keylist_next (listctx, r_key);
464       gpgme_release (listctx);
465     }
466   return err;
467 }