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