gpg: Switch to a hash and CERT record based PKA system.
[gnupg.git] / g10 / mainproc.c
1 /* mainproc.c - handle packets
2  * Copyright (C) 1998-2009 Free Software Foundation, Inc.
3  * Copyright (C) 2013-2014 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG 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 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG 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, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <time.h>
27
28 #include "gpg.h"
29 #include "util.h"
30 #include "packet.h"
31 #include "iobuf.h"
32 #include "options.h"
33 #include "keydb.h"
34 #include "filter.h"
35 #include "main.h"
36 #include "status.h"
37 #include "i18n.h"
38 #include "trustdb.h"
39 #include "keyserver-internal.h"
40 #include "photoid.h"
41 #include "pka.h"
42 #include "mbox-util.h"
43
44
45 /* Put an upper limit on nested packets.  The 32 is an arbitrary
46    value, a much lower should actually be sufficient.  */
47 #define MAX_NESTING_DEPTH 32
48
49
50 /* An object to build a list of keyid related info.  */
51 struct kidlist_item
52 {
53   struct kidlist_item *next;
54   u32 kid[2];
55   int pubkey_algo;
56   int reason;
57 };
58
59
60 /*
61  * Object to hold the processing context.
62  */
63 typedef struct mainproc_context *CTX;
64 struct mainproc_context
65 {
66   ctrl_t ctrl;
67   struct mainproc_context *anchor;  /* May be useful in the future. */
68   PKT_public_key *last_pubkey;
69   PKT_user_id     *last_user_id;
70   md_filter_context_t mfx;
71   int sigs_only;    /* Process only signatures and reject all other stuff. */
72   int encrypt_only; /* Process only encryption messages. */
73
74   /* Name of the file with the complete signature or the file with the
75      detached signature.  This is currently only used to deduce the
76      file name of the data file if that has not been given. */
77   const char *sigfilename;
78
79   /* A structure to describe the signed data in case of a detached
80      signature. */
81   struct
82   {
83     /* A file descriptor of the the signed data.  Only used if not -1. */
84     int data_fd;
85     /* A list of filenames with the data files or NULL. This is only
86        used if DATA_FD is -1. */
87     strlist_t data_names;
88     /* Flag to indicated that either one of the next previous fields
89        is used.  This is only needed for better readability. */
90     int used;
91   } signed_data;
92
93   DEK *dek;
94   int last_was_session_key;
95   kbnode_t list;    /* The current list of packets. */
96   iobuf_t iobuf;    /* Used to get the filename etc. */
97   int trustletter;  /* Temporary usage in list_node. */
98   ulong symkeys;
99   struct kidlist_item *pkenc_list; /* List of encryption packets. */
100   struct {
101     unsigned int sig_seen:1;      /* Set to true if a signature packet
102                                      has been seen. */
103     unsigned int data:1;          /* Any data packet seen */
104     unsigned int uncompress_failed:1;
105   } any;
106 };
107
108
109 /*** Local prototypes.  ***/
110 static int do_proc_packets (CTX c, iobuf_t a);
111 static void list_node (CTX c, kbnode_t node);
112 static void proc_tree (CTX c, kbnode_t node);
113 static int literals_seen;
114
115
116 /*** Functions.  ***/
117
118
119 void
120 reset_literals_seen(void)
121 {
122   literals_seen = 0;
123 }
124
125
126 static void
127 release_list( CTX c )
128 {
129   if (!c->list)
130     return;
131   proc_tree (c, c->list);
132   release_kbnode (c->list);
133   while (c->pkenc_list)
134     {
135       struct kidlist_item *tmp = c->pkenc_list->next;
136       xfree (c->pkenc_list);
137       c->pkenc_list = tmp;
138     }
139   c->pkenc_list = NULL;
140   c->list = NULL;
141   c->any.data = 0;
142   c->any.uncompress_failed = 0;
143   c->last_was_session_key = 0;
144   xfree (c->dek);
145   c->dek = NULL;
146 }
147
148
149 static int
150 add_onepass_sig (CTX c, PACKET *pkt)
151 {
152   kbnode_t node;
153
154   if (c->list) /* Add another packet. */
155     add_kbnode (c->list, new_kbnode (pkt));
156   else /* Insert the first one.  */
157     c->list = node = new_kbnode (pkt);
158
159   return 1;
160 }
161
162
163 static int
164 add_gpg_control (CTX c, PACKET *pkt)
165 {
166   if ( pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
167     {
168       /* New clear text signature.
169        * Process the last one and reset everything */
170       release_list(c);
171     }
172
173   if (c->list)  /* Add another packet.  */
174     add_kbnode (c->list, new_kbnode (pkt));
175   else /* Insert the first one. */
176     c->list = new_kbnode (pkt);
177
178   return 1;
179 }
180
181
182 static int
183 add_user_id (CTX c, PACKET *pkt)
184 {
185   if (!c->list)
186     {
187       log_error ("orphaned user ID\n");
188       return 0;
189     }
190   add_kbnode (c->list, new_kbnode (pkt));
191   return 1;
192 }
193
194
195 static int
196 add_subkey (CTX c, PACKET *pkt)
197 {
198   if (!c->list)
199     {
200       log_error ("subkey w/o mainkey\n");
201       return 0;
202     }
203   add_kbnode (c->list, new_kbnode (pkt));
204   return 1;
205 }
206
207
208 static int
209 add_ring_trust (CTX c, PACKET *pkt)
210 {
211   if (!c->list)
212     {
213       log_error ("ring trust w/o key\n");
214       return 0;
215     }
216   add_kbnode (c->list, new_kbnode (pkt));
217   return 1;
218 }
219
220
221 static int
222 add_signature (CTX c, PACKET *pkt)
223 {
224   kbnode_t node;
225
226   c->any.sig_seen = 1;
227   if (pkt->pkttype == PKT_SIGNATURE && !c->list)
228     {
229       /* This is the first signature for the following datafile.
230        * GPG does not write such packets; instead it always uses
231        * onepass-sig packets.  The drawback of PGP's method
232        * of prepending the signature to the data is
233        * that it is not possible to make a signature from data read
234        * from stdin.    (GPG is able to read PGP stuff anyway.) */
235       node = new_kbnode (pkt);
236       c->list = node;
237       return 1;
238     }
239   else if (!c->list)
240     return 0; /* oops (invalid packet sequence)*/
241   else if (!c->list->pkt)
242     BUG();    /* so nicht */
243
244   /* Add a new signature node item at the end. */
245   node = new_kbnode (pkt);
246   add_kbnode (c->list, node);
247
248   return 1;
249 }
250
251 static int
252 symkey_decrypt_seskey (DEK *dek, byte *seskey, size_t slen)
253 {
254   gcry_cipher_hd_t hd;
255
256   if(slen < 17 || slen > 33)
257     {
258       log_error ( _("weird size for an encrypted session key (%d)\n"),
259                   (int)slen);
260       return GPG_ERR_BAD_KEY;
261     }
262
263   if (openpgp_cipher_open (&hd, dek->algo, GCRY_CIPHER_MODE_CFB, 1))
264       BUG ();
265   if (gcry_cipher_setkey ( hd, dek->key, dek->keylen ))
266     BUG ();
267   gcry_cipher_setiv ( hd, NULL, 0 );
268   gcry_cipher_decrypt ( hd, seskey, slen, NULL, 0 );
269   gcry_cipher_close ( hd );
270
271   /* Now we replace the dek components with the real session key to
272      decrypt the contents of the sequencing packet. */
273
274   dek->keylen=slen-1;
275   dek->algo=seskey[0];
276
277   if(dek->keylen > DIM(dek->key))
278     BUG ();
279
280   memcpy(dek->key, seskey + 1, dek->keylen);
281
282   /*log_hexdump( "thekey", dek->key, dek->keylen );*/
283
284   return 0;
285 }
286
287
288 static void
289 proc_symkey_enc (CTX c, PACKET *pkt)
290 {
291   PKT_symkey_enc *enc;
292
293   enc = pkt->pkt.symkey_enc;
294   if (!enc)
295     log_error ("invalid symkey encrypted packet\n");
296   else if(!c->dek)
297     {
298       int algo = enc->cipher_algo;
299       const char *s = openpgp_cipher_algo_name (algo);
300
301       if (!openpgp_cipher_test_algo (algo))
302         {
303           if (!opt.quiet)
304             {
305               if (enc->seskeylen)
306                 log_info (_("%s encrypted session key\n"), s );
307               else
308                 log_info (_("%s encrypted data\n"), s );
309             }
310         }
311       else
312         log_error (_("encrypted with unknown algorithm %d\n"), algo);
313
314       if (openpgp_md_test_algo (enc->s2k.hash_algo))
315         {
316           log_error(_("passphrase generated with unknown digest"
317                       " algorithm %d\n"),enc->s2k.hash_algo);
318           s = NULL;
319         }
320
321       c->last_was_session_key = 2;
322       if (!s || opt.list_only)
323         goto leave;
324
325       if (opt.override_session_key)
326         {
327           c->dek = xmalloc_clear (sizeof *c->dek);
328           if (get_override_session_key (c->dek, opt.override_session_key))
329             {
330               xfree (c->dek);
331               c->dek = NULL;
332             }
333         }
334       else
335         {
336           c->dek = passphrase_to_dek (NULL, 0, algo, &enc->s2k, 3, NULL, NULL);
337           if (c->dek)
338             {
339               c->dek->symmetric = 1;
340
341               /* FIXME: This doesn't work perfectly if a symmetric key
342                  comes before a public key in the message - if the
343                  user doesn't know the passphrase, then there is a
344                  chance that the "decrypted" algorithm will happen to
345                  be a valid one, which will make the returned dek
346                  appear valid, so we won't try any public keys that
347                  come later. */
348               if (enc->seskeylen)
349                 {
350                   if (symkey_decrypt_seskey (c->dek,
351                                              enc->seskey, enc->seskeylen))
352                     {
353                       xfree (c->dek);
354                       c->dek = NULL;
355                     }
356                 }
357               else
358                 c->dek->algo_info_printed = 1;
359             }
360         }
361     }
362
363  leave:
364   c->symkeys++;
365   free_packet (pkt);
366 }
367
368
369 static void
370 proc_pubkey_enc (CTX c, PACKET *pkt)
371 {
372   PKT_pubkey_enc *enc;
373   int result = 0;
374
375   /* Check whether the secret key is available and store in this case.  */
376   c->last_was_session_key = 1;
377   enc = pkt->pkt.pubkey_enc;
378   /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
379   /* Hmmm: why do I have this algo check here - anyway there is
380    * function to check it. */
381   if (opt.verbose)
382     log_info (_("public key is %s\n"), keystr (enc->keyid));
383
384   if (is_status_enabled())
385     {
386       char buf[50];
387       /* FIXME: For ECC support we need to map the OpenPGP algo number
388          to the Libgcrypt defined one.  This is due a chicken-egg
389          problem: We need to have code in Libgcrypt for a new
390          algorithm so to implement a proposed new algorithm before the
391          IANA will finally assign an OpenPGP indentifier.  */
392       snprintf (buf, sizeof buf, "%08lX%08lX %d 0",
393                 (ulong)enc->keyid[0], (ulong)enc->keyid[1], enc->pubkey_algo);
394       write_status_text (STATUS_ENC_TO, buf);
395     }
396
397   if (!opt.list_only && opt.override_session_key)
398     {
399       /* It does not make much sense to store the session key in
400        * secure memory because it has already been passed on the
401        * command line and the GCHQ knows about it.  */
402       c->dek = xmalloc_clear (sizeof *c->dek);
403       result = get_override_session_key (c->dek, opt.override_session_key);
404       if (result)
405         {
406           xfree (c->dek);
407           c->dek = NULL;
408         }
409     }
410   else if (is_ELGAMAL(enc->pubkey_algo)
411            || enc->pubkey_algo == PUBKEY_ALGO_DSA
412            || enc->pubkey_algo == PUBKEY_ALGO_ECDSA
413            || enc->pubkey_algo == PUBKEY_ALGO_EDDSA
414            || enc->pubkey_algo == PUBKEY_ALGO_ECDH
415            || is_RSA (enc->pubkey_algo)
416            || enc->pubkey_algo == PUBKEY_ALGO_ELGAMAL)
417     {
418       /* Note that we also allow type 20 Elgamal keys for decryption.
419          There are still a couple of those keys in active use as a
420          subkey.  */
421
422       /* FIXME: Store this all in a list and process it later so that
423          we can prioritize what key to use.  This gives a better user
424          experience if wildcard keyids are used.  */
425       if  (!c->dek && ((!enc->keyid[0] && !enc->keyid[1])
426                        || opt.try_all_secrets
427                        || have_secret_key_with_kid (enc->keyid)))
428         {
429           if(opt.list_only)
430             result = -1;
431           else
432             {
433               c->dek = xmalloc_secure_clear (sizeof *c->dek);
434               if ((result = get_session_key (enc, c->dek)))
435                 {
436                   /* Error: Delete the DEK. */
437                   xfree (c->dek);
438                   c->dek = NULL;
439                 }
440             }
441         }
442       else
443         result = GPG_ERR_NO_SECKEY;
444     }
445   else
446     result = GPG_ERR_PUBKEY_ALGO;
447
448   if (result == -1)
449     ;
450   else
451     {
452       /* Store it for later display.  */
453       struct kidlist_item *x = xmalloc (sizeof *x);
454       x->kid[0] = enc->keyid[0];
455       x->kid[1] = enc->keyid[1];
456       x->pubkey_algo = enc->pubkey_algo;
457       x->reason = result;
458       x->next = c->pkenc_list;
459       c->pkenc_list = x;
460
461       if (!result && opt.verbose > 1)
462         log_info (_("public key encrypted data: good DEK\n"));
463     }
464
465   free_packet(pkt);
466 }
467
468
469 /*
470  * Print the list of public key encrypted packets which we could
471  * not decrypt.
472  */
473 static void
474 print_pkenc_list (struct kidlist_item *list, int failed)
475 {
476   for (; list; list = list->next)
477     {
478       PKT_public_key *pk;
479       const char *algstr;
480
481       if (failed && !list->reason)
482         continue;
483       if (!failed && list->reason)
484         continue;
485
486       algstr = openpgp_pk_algo_name (list->pubkey_algo);
487       pk = xmalloc_clear (sizeof *pk);
488
489       if (!algstr)
490         algstr = "[?]";
491       pk->pubkey_algo = list->pubkey_algo;
492       if (!get_pubkey (pk, list->kid))
493         {
494           char *p;
495           log_info (_("encrypted with %u-bit %s key, ID %s, created %s\n"),
496                     nbits_from_pk (pk), algstr, keystr_from_pk(pk),
497                     strtimestamp (pk->timestamp));
498           p = get_user_id_native (list->kid);
499           log_printf (_("      \"%s\"\n"), p);
500           xfree (p);
501         }
502       else
503         log_info (_("encrypted with %s key, ID %s\n"),
504                   algstr, keystr(list->kid));
505
506       free_public_key (pk);
507
508       if (gpg_err_code (list->reason) == GPG_ERR_NO_SECKEY)
509         {
510           if (is_status_enabled())
511             {
512               char buf[20];
513               snprintf (buf, sizeof buf, "%08lX%08lX",
514                         (ulong)list->kid[0], (ulong)list->kid[1]);
515               write_status_text (STATUS_NO_SECKEY, buf);
516             }
517         }
518       else if (list->reason)
519         {
520           log_info (_("public key decryption failed: %s\n"),
521                     gpg_strerror (list->reason));
522           write_status_error ("pkdecrypt_failed", list->reason);
523         }
524     }
525 }
526
527
528 static void
529 proc_encrypted (CTX c, PACKET *pkt)
530 {
531   int result = 0;
532
533   if (!opt.quiet)
534     {
535       if (c->symkeys>1)
536         log_info (_("encrypted with %lu passphrases\n"), c->symkeys);
537       else if (c->symkeys == 1)
538         log_info (_("encrypted with 1 passphrase\n"));
539       print_pkenc_list ( c->pkenc_list, 1 );
540       print_pkenc_list ( c->pkenc_list, 0 );
541     }
542
543   /* FIXME: Figure out the session key by looking at all pkenc packets. */
544
545   write_status (STATUS_BEGIN_DECRYPTION);
546
547   /*log_debug("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
548   if (opt.list_only)
549     result = -1;
550   else if (!c->dek && !c->last_was_session_key)
551     {
552       int algo;
553       STRING2KEY s2kbuf;
554       STRING2KEY *s2k = NULL;
555       int canceled;
556
557       if (opt.override_session_key)
558         {
559           c->dek = xmalloc_clear (sizeof *c->dek);
560           result = get_override_session_key (c->dek, opt.override_session_key);
561           if (result)
562             {
563               xfree (c->dek);
564               c->dek = NULL;
565             }
566         }
567       else
568         {
569           /* Assume this is old style conventional encrypted data. */
570           algo = opt.def_cipher_algo;
571           if (algo)
572             log_info (_("assuming %s encrypted data\n"),
573                       openpgp_cipher_algo_name (algo));
574           else if (openpgp_cipher_test_algo (CIPHER_ALGO_IDEA))
575             {
576               algo = opt.def_cipher_algo;
577               if (!algo)
578                 algo = opt.s2k_cipher_algo;
579               log_info (_("IDEA cipher unavailable, "
580                           "optimistically attempting to use %s instead\n"),
581                         openpgp_cipher_algo_name (algo));
582             }
583           else
584             {
585               algo = CIPHER_ALGO_IDEA;
586               if (!opt.s2k_digest_algo)
587                 {
588                   /* If no digest is given we assume SHA-1. */
589                   s2kbuf.mode = 0;
590                   s2kbuf.hash_algo = DIGEST_ALGO_SHA1;
591                   s2k = &s2kbuf;
592                 }
593               log_info (_("assuming %s encrypted data\n"), "IDEA");
594             }
595
596           c->dek = passphrase_to_dek ( NULL, 0, algo, s2k, 3, NULL, &canceled);
597           if (c->dek)
598             c->dek->algo_info_printed = 1;
599           else if (canceled)
600             result = gpg_error (GPG_ERR_CANCELED);
601           else
602             result = gpg_error (GPG_ERR_INV_PASSPHRASE);
603         }
604     }
605   else if (!c->dek)
606     result = GPG_ERR_NO_SECKEY;
607
608   if (!result)
609     result = decrypt_data (c->ctrl, c, pkt->pkt.encrypted, c->dek );
610
611   if (result == -1)
612     ;
613   else if (!result || (gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE
614                        && opt.ignore_mdc_error))
615     {
616       write_status (STATUS_DECRYPTION_OKAY);
617       if (opt.verbose > 1)
618         log_info(_("decryption okay\n"));
619       if (pkt->pkt.encrypted->mdc_method && !result)
620         write_status (STATUS_GOODMDC);
621       else if (!opt.no_mdc_warn)
622         log_info (_("WARNING: message was not integrity protected\n"));
623     }
624   else if (gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE)
625     {
626       glo_ctrl.lasterr = result;
627       log_error (_("WARNING: encrypted message has been manipulated!\n"));
628       write_status (STATUS_BADMDC);
629       write_status (STATUS_DECRYPTION_FAILED);
630     }
631   else
632     {
633       if (gpg_err_code (result) == GPG_ERR_BAD_KEY
634           && *c->dek->s2k_cacheid != '\0')
635         {
636           log_debug (_("cleared passphrase cached with ID: %s\n"),
637                      c->dek->s2k_cacheid);
638           passphrase_clear_cache (NULL, c->dek->s2k_cacheid, 0);
639         }
640       glo_ctrl.lasterr = result;
641       write_status (STATUS_DECRYPTION_FAILED);
642       log_error (_("decryption failed: %s\n"), gpg_strerror (result));
643       /* Hmmm: does this work when we have encrypted using multiple
644        * ways to specify the session key (symmmetric and PK). */
645     }
646
647   xfree (c->dek);
648   c->dek = NULL;
649   free_packet (pkt);
650   c->last_was_session_key = 0;
651   write_status (STATUS_END_DECRYPTION);
652 }
653
654
655 static void
656 proc_plaintext( CTX c, PACKET *pkt )
657 {
658   PKT_plaintext *pt = pkt->pkt.plaintext;
659   int any, clearsig, rc;
660   kbnode_t n;
661
662   literals_seen++;
663
664   if (pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8))
665     log_info (_("Note: sender requested \"for-your-eyes-only\"\n"));
666   else if (opt.verbose)
667     log_info (_("original file name='%.*s'\n"), pt->namelen, pt->name);
668
669   free_md_filter_context (&c->mfx);
670   if (gcry_md_open (&c->mfx.md, 0, 0))
671     BUG ();
672   /* fixme: we may need to push the textfilter if we have sigclass 1
673    * and no armoring - Not yet tested
674    * Hmmm, why don't we need it at all if we have sigclass 1
675    * Should we assume that plaintext in mode 't' has always sigclass 1??
676    * See: Russ Allbery's mail 1999-02-09
677    */
678   any = clearsig = 0;
679   for (n=c->list; n; n = n->next )
680     {
681       if (n->pkt->pkttype == PKT_ONEPASS_SIG)
682         {
683           /* The onepass signature case. */
684           if (n->pkt->pkt.onepass_sig->digest_algo)
685             {
686               gcry_md_enable (c->mfx.md, n->pkt->pkt.onepass_sig->digest_algo);
687               any = 1;
688             }
689         }
690       else if (n->pkt->pkttype == PKT_GPG_CONTROL
691                && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START)
692         {
693           /* The clearsigned message case. */
694           size_t datalen = n->pkt->pkt.gpg_control->datalen;
695           const byte *data = n->pkt->pkt.gpg_control->data;
696
697           /* Check that we have at least the sigclass and one hash.  */
698           if  (datalen < 2)
699             log_fatal ("invalid control packet CTRLPKT_CLEARSIGN_START\n");
700           /* Note that we don't set the clearsig flag for not-dash-escaped
701            * documents.  */
702           clearsig = (*data == 0x01);
703           for (data++, datalen--; datalen; datalen--, data++)
704             gcry_md_enable (c->mfx.md, *data);
705           any = 1;
706           break;  /* Stop here as one-pass signature packets are not
707                      expected.  */
708         }
709       else if (n->pkt->pkttype == PKT_SIGNATURE)
710         {
711           /* The SIG+LITERAL case that PGP used to use.  */
712           gcry_md_enable ( c->mfx.md, n->pkt->pkt.signature->digest_algo );
713           any = 1;
714         }
715     }
716
717   if (!any && !opt.skip_verify)
718     {
719       /* This is for the old GPG LITERAL+SIG case.  It's not legal
720          according to 2440, so hopefully it won't come up that often.
721          There is no good way to specify what algorithms to use in
722          that case, so these there are the historical answer. */
723         gcry_md_enable (c->mfx.md, DIGEST_ALGO_RMD160);
724         gcry_md_enable (c->mfx.md, DIGEST_ALGO_SHA1);
725     }
726   if (DBG_HASHING)
727     {
728       gcry_md_debug (c->mfx.md, "verify");
729       if (c->mfx.md2)
730         gcry_md_debug (c->mfx.md2, "verify2");
731     }
732
733   rc=0;
734
735   if (literals_seen > 1)
736     {
737       log_info (_("WARNING: multiple plaintexts seen\n"));
738
739       if (!opt.flags.allow_multiple_messages)
740         {
741           write_status_text (STATUS_ERROR, "proc_pkt.plaintext 89_BAD_DATA");
742           log_inc_errorcount ();
743           rc = gpg_error (GPG_ERR_UNEXPECTED);
744         }
745     }
746
747   if (!rc)
748     {
749       rc = handle_plaintext (pt, &c->mfx, c->sigs_only, clearsig);
750       if (gpg_err_code (rc) == GPG_ERR_EACCES && !c->sigs_only)
751         {
752           /* Can't write output but we hash it anyway to check the
753              signature. */
754           rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
755         }
756     }
757
758   if (rc)
759     log_error ("handle plaintext failed: %s\n", gpg_strerror (rc));
760
761   free_packet(pkt);
762   c->last_was_session_key = 0;
763
764   /* We add a marker control packet instead of the plaintext packet.
765    * This is so that we can later detect invalid packet sequences.  */
766   n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK, NULL, 0));
767   if (c->list)
768     add_kbnode (c->list, n);
769   else
770     c->list = n;
771 }
772
773
774 static int
775 proc_compressed_cb (iobuf_t a, void *info)
776 {
777   if ( ((CTX)info)->signed_data.used
778        && ((CTX)info)->signed_data.data_fd != -1)
779     return proc_signature_packets_by_fd (((CTX)info)->ctrl, info, a,
780                                          ((CTX)info)->signed_data.data_fd);
781   else
782     return proc_signature_packets (((CTX)info)->ctrl, info, a,
783                                    ((CTX)info)->signed_data.data_names,
784                                    ((CTX)info)->sigfilename );
785 }
786
787
788 static int
789 proc_encrypt_cb (iobuf_t a, void *info )
790 {
791   CTX c = info;
792   return proc_encryption_packets (c->ctrl, info, a );
793 }
794
795
796 static int
797 proc_compressed (CTX c, PACKET *pkt)
798 {
799   PKT_compressed *zd = pkt->pkt.compressed;
800   int rc;
801
802   /*printf("zip: compressed data packet\n");*/
803   if (c->sigs_only)
804     rc = handle_compressed (c->ctrl, c, zd, proc_compressed_cb, c);
805   else if( c->encrypt_only )
806     rc = handle_compressed (c->ctrl, c, zd, proc_encrypt_cb, c);
807   else
808     rc = handle_compressed (c->ctrl, c, zd, NULL, NULL);
809
810   if (gpg_err_code (rc) == GPG_ERR_BAD_DATA)
811     {
812       if  (!c->any.uncompress_failed)
813         {
814           CTX cc;
815
816           for (cc=c; cc; cc = cc->anchor)
817             cc->any.uncompress_failed = 1;
818           log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
819         }
820     }
821   else if (rc)
822     log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
823
824   free_packet(pkt);
825   c->last_was_session_key = 0;
826   return rc;
827 }
828
829
830 /*
831  * check the signature
832  * Returns: 0 = valid signature or an error code
833  */
834 static int
835 do_check_sig (CTX c, kbnode_t node, int *is_selfsig,
836               int *is_expkey, int *is_revkey)
837 {
838   PKT_signature *sig;
839   gcry_md_hd_t md = NULL;
840   gcry_md_hd_t md2 = NULL;
841   int algo, rc;
842
843   assert (node->pkt->pkttype == PKT_SIGNATURE);
844   if (is_selfsig)
845     *is_selfsig = 0;
846   sig = node->pkt->pkt.signature;
847
848   algo = sig->digest_algo;
849   rc = openpgp_md_test_algo (algo);
850   if (rc)
851     return rc;
852
853   if (sig->sig_class == 0x00)
854     {
855       if (c->mfx.md)
856         {
857           if (gcry_md_copy (&md, c->mfx.md ))
858             BUG ();
859         }
860       else /* detached signature */
861         {
862           /* signature_check() will enable the md. */
863           if (gcry_md_open (&md, 0, 0 ))
864             BUG ();
865         }
866     }
867   else if (sig->sig_class == 0x01)
868     {
869       /* How do we know that we have to hash the (already hashed) text
870          in canonical mode ??? (calculating both modes???) */
871       if (c->mfx.md)
872         {
873           if (gcry_md_copy (&md, c->mfx.md ))
874             BUG ();
875           if (c->mfx.md2 && gcry_md_copy (&md2, c->mfx.md2))
876             BUG ();
877         }
878       else /* detached signature */
879         {
880           log_debug ("Do we really need this here?");
881           /* signature_check() will enable the md*/
882           if (gcry_md_open (&md, 0, 0 ))
883             BUG ();
884           if (gcry_md_open (&md2, 0, 0 ))
885             BUG ();
886         }
887     }
888   else if ((sig->sig_class&~3) == 0x10
889            ||   sig->sig_class == 0x18
890            ||   sig->sig_class == 0x1f
891            ||   sig->sig_class == 0x20
892            ||   sig->sig_class == 0x28
893            ||   sig->sig_class == 0x30)
894     {
895       if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
896           || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY)
897         {
898           return check_key_signature( c->list, node, is_selfsig );
899         }
900       else if (sig->sig_class == 0x20)
901         {
902           log_error (_("standalone revocation - "
903                        "use \"gpg --import\" to apply\n"));
904           return GPG_ERR_NOT_PROCESSED;
905         }
906       else
907         {
908           log_error ("invalid root packet for sigclass %02x\n", sig->sig_class);
909           return GPG_ERR_SIG_CLASS;
910         }
911     }
912   else
913     return GPG_ERR_SIG_CLASS;
914
915   rc = signature_check2 (sig, md, NULL, is_expkey, is_revkey, NULL);
916   if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE && md2)
917     rc = signature_check2 (sig, md2, NULL, is_expkey, is_revkey, NULL);
918
919   gcry_md_close (md);
920   gcry_md_close (md2);
921
922   return rc;
923 }
924
925
926 static void
927 print_userid (PACKET *pkt)
928 {
929   if (!pkt)
930     BUG();
931
932   if (pkt->pkttype != PKT_USER_ID)
933     {
934       es_printf ("ERROR: unexpected packet type %d", pkt->pkttype );
935       return;
936     }
937   if (opt.with_colons)
938     {
939       if (pkt->pkt.user_id->attrib_data)
940         es_printf("%u %lu",
941                   pkt->pkt.user_id->numattribs,
942                   pkt->pkt.user_id->attrib_len);
943       else
944         es_write_sanitized (es_stdout, pkt->pkt.user_id->name,
945                             pkt->pkt.user_id->len, ":", NULL);
946     }
947   else
948     print_utf8_buffer (es_stdout, pkt->pkt.user_id->name,
949                        pkt->pkt.user_id->len );
950 }
951
952
953 /*
954  * List the keyblock in a user friendly way
955  */
956 static void
957 list_node (CTX c, kbnode_t node)
958 {
959   int mainkey;
960   char pkstrbuf[PUBKEY_STRING_SIZE];
961
962   if (!node)
963     ;
964   else if ((mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY))
965            || node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
966     {
967       PKT_public_key *pk = node->pkt->pkt.public_key;
968
969       if (opt.with_colons)
970         {
971           u32 keyid[2];
972
973           keyid_from_pk( pk, keyid );
974           if (mainkey)
975             c->trustletter = (opt.fast_list_mode?
976                               0 : get_validity_info( pk, NULL));
977           es_printf ("%s:", mainkey? "pub":"sub" );
978           if (c->trustletter)
979             es_putc (c->trustletter, es_stdout);
980           es_printf (":%u:%d:%08lX%08lX:%s:%s::",
981                      nbits_from_pk( pk ),
982                      pk->pubkey_algo,
983                      (ulong)keyid[0],(ulong)keyid[1],
984                      colon_datestr_from_pk( pk ),
985                      colon_strtime (pk->expiredate) );
986           if (mainkey && !opt.fast_list_mode)
987             es_putc (get_ownertrust_info (pk), es_stdout);
988           es_putc (':', es_stdout);
989         }
990       else
991         es_printf ("%s  %s/%s %s",
992                    mainkey? "pub":"sub",
993                    pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
994                    keystr_from_pk (pk),
995                    datestr_from_pk (pk));
996
997       if (pk->flags.revoked)
998         {
999           es_printf (" [");
1000           es_printf (_("revoked: %s"), revokestr_from_pk (pk));
1001           es_printf ("]\n");
1002         }
1003       else if( pk->expiredate && !opt.with_colons)
1004         {
1005           es_printf (" [");
1006           es_printf (_("expires: %s"), expirestr_from_pk (pk));
1007           es_printf ("]\n");
1008         }
1009       else
1010         es_putc ('\n', es_stdout);
1011
1012       if ((mainkey && opt.fingerprint) || opt.fingerprint > 1)
1013         print_fingerprint (NULL, pk, 0);
1014
1015       if (opt.with_colons)
1016         {
1017           if (node->next && node->next->pkt->pkttype == PKT_RING_TRUST)
1018             es_printf ("rtv:1:%u:\n",
1019                        node->next->pkt->pkt.ring_trust->trustval);
1020         }
1021
1022       if (mainkey)
1023         {
1024           /* Now list all userids with their signatures. */
1025           for (node = node->next; node; node = node->next)
1026             {
1027               if (node->pkt->pkttype == PKT_SIGNATURE)
1028                 {
1029                   list_node (c,  node );
1030                 }
1031               else if (node->pkt->pkttype == PKT_USER_ID)
1032                 {
1033                   if (opt.with_colons)
1034                     es_printf ("%s:::::::::",
1035                                node->pkt->pkt.user_id->attrib_data?"uat":"uid");
1036                   else
1037                     es_printf ("uid%*s", 28, "" );
1038                   print_userid (node->pkt);
1039                   if (opt.with_colons)
1040                     es_putc (':', es_stdout);
1041                   es_putc ('\n', es_stdout);
1042                   if (opt.with_colons
1043                       && node->next
1044                       && node->next->pkt->pkttype == PKT_RING_TRUST)
1045                     {
1046                       es_printf ("rtv:2:%u:\n",
1047                                  node->next->pkt->pkt.ring_trust?
1048                                  node->next->pkt->pkt.ring_trust->trustval : 0);
1049                     }
1050                 }
1051               else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1052                 {
1053                   list_node(c,  node );
1054                 }
1055             }
1056         }
1057     }
1058   else if ((mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
1059            || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1060     {
1061
1062       log_debug ("FIXME: No way to print secret key packets here\n");
1063       /* fixme: We may use a fucntion to turn a secret key packet into
1064          a public key one and use that here.  */
1065     }
1066   else if (node->pkt->pkttype == PKT_SIGNATURE)
1067     {
1068       PKT_signature *sig = node->pkt->pkt.signature;
1069       int is_selfsig = 0;
1070       int rc2 = 0;
1071       size_t n;
1072       char *p;
1073       int sigrc = ' ';
1074
1075       if (!opt.verbose)
1076         return;
1077
1078       if (sig->sig_class == 0x20 || sig->sig_class == 0x30)
1079         es_fputs ("rev", es_stdout);
1080       else
1081         es_fputs ("sig", es_stdout);
1082       if (opt.check_sigs)
1083         {
1084           fflush (stdout);
1085           rc2 = do_check_sig (c, node, &is_selfsig, NULL, NULL);
1086           switch (gpg_err_code (rc2))
1087             {
1088             case 0:                       sigrc = '!'; break;
1089             case GPG_ERR_BAD_SIGNATURE:   sigrc = '-'; break;
1090             case GPG_ERR_NO_PUBKEY:
1091             case GPG_ERR_UNUSABLE_PUBKEY: sigrc = '?'; break;
1092             default:                      sigrc = '%'; break;
1093             }
1094         }
1095       else /* Check whether this is a self signature.  */
1096         {
1097           u32 keyid[2];
1098
1099           if (c->list->pkt->pkttype == PKT_PUBLIC_KEY
1100               || c->list->pkt->pkttype == PKT_SECRET_KEY )
1101             {
1102               keyid_from_pk (c->list->pkt->pkt.public_key, keyid);
1103
1104               if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
1105                 is_selfsig = 1;
1106             }
1107         }
1108
1109       if (opt.with_colons)
1110         {
1111           es_putc (':', es_stdout);
1112           if (sigrc != ' ')
1113             es_putc (sigrc, es_stdout);
1114           es_printf ("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1115                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1116                      colon_datestr_from_sig (sig),
1117                      colon_expirestr_from_sig (sig));
1118
1119           if (sig->trust_depth || sig->trust_value)
1120             es_printf ("%d %d",sig->trust_depth,sig->trust_value);
1121           es_putc (':', es_stdout);
1122
1123           if (sig->trust_regexp)
1124             es_write_sanitized (es_stdout, sig->trust_regexp,
1125                                 strlen (sig->trust_regexp), ":", NULL);
1126           es_putc (':', es_stdout);
1127         }
1128       else
1129         es_printf ("%c       %s %s   ",
1130                    sigrc, keystr (sig->keyid), datestr_from_sig(sig));
1131       if (sigrc == '%')
1132         es_printf ("[%s] ", gpg_strerror (rc2) );
1133       else if (sigrc == '?')
1134         ;
1135       else if (is_selfsig)
1136         {
1137           if (opt.with_colons)
1138             es_putc (':', es_stdout);
1139           es_fputs (sig->sig_class == 0x18? "[keybind]":"[selfsig]", es_stdout);
1140           if (opt.with_colons)
1141             es_putc (':', es_stdout);
1142         }
1143       else if (!opt.fast_list_mode)
1144         {
1145           p = get_user_id (sig->keyid, &n);
1146           es_write_sanitized (es_stdout, p, n,
1147                               opt.with_colons?":":NULL, NULL );
1148           xfree (p);
1149         }
1150       if (opt.with_colons)
1151         es_printf (":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1152       es_putc ('\n', es_stdout);
1153     }
1154   else
1155     log_error ("invalid node with packet of type %d\n", node->pkt->pkttype);
1156 }
1157
1158
1159 int
1160 proc_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1161 {
1162   int rc;
1163   CTX c = xmalloc_clear (sizeof *c);
1164
1165   c->ctrl = ctrl;
1166   c->anchor = anchor;
1167   rc = do_proc_packets (c, a);
1168   xfree (c);
1169
1170   return rc;
1171 }
1172
1173
1174 int
1175 proc_signature_packets (ctrl_t ctrl, void *anchor, iobuf_t a,
1176                         strlist_t signedfiles, const char *sigfilename )
1177 {
1178   CTX c = xmalloc_clear (sizeof *c);
1179   int rc;
1180
1181   c->ctrl = ctrl;
1182   c->anchor = anchor;
1183   c->sigs_only = 1;
1184
1185   c->signed_data.data_fd = -1;
1186   c->signed_data.data_names = signedfiles;
1187   c->signed_data.used = !!signedfiles;
1188
1189   c->sigfilename = sigfilename;
1190   rc = do_proc_packets ( c, a );
1191
1192   /* If we have not encountered any signature we print an error
1193      messages, send a NODATA status back and return an error code.
1194      Using log_error is required because verify_files does not check
1195      error codes for each file but we want to terminate the process
1196      with an error. */
1197   if (!rc && !c->any.sig_seen)
1198     {
1199       write_status_text (STATUS_NODATA, "4");
1200       log_error (_("no signature found\n"));
1201       rc = GPG_ERR_NO_DATA;
1202     }
1203
1204   /* Propagate the signature seen flag upward. Do this only on success
1205      so that we won't issue the nodata status several times.  */
1206   if (!rc && c->anchor && c->any.sig_seen)
1207     c->anchor->any.sig_seen = 1;
1208
1209   xfree (c);
1210   return rc;
1211 }
1212
1213
1214 int
1215 proc_signature_packets_by_fd (ctrl_t ctrl,
1216                               void *anchor, iobuf_t a, int signed_data_fd )
1217 {
1218   int rc;
1219   CTX c;
1220
1221   c = xtrycalloc (1, sizeof *c);
1222   if (!c)
1223     return gpg_error_from_syserror ();
1224
1225   c->ctrl = ctrl;
1226   c->anchor = anchor;
1227   c->sigs_only = 1;
1228
1229   c->signed_data.data_fd = signed_data_fd;
1230   c->signed_data.data_names = NULL;
1231   c->signed_data.used = (signed_data_fd != -1);
1232
1233   rc = do_proc_packets ( c, a );
1234
1235   /* If we have not encountered any signature we print an error
1236      messages, send a NODATA status back and return an error code.
1237      Using log_error is required because verify_files does not check
1238      error codes for each file but we want to terminate the process
1239      with an error. */
1240   if (!rc && !c->any.sig_seen)
1241     {
1242       write_status_text (STATUS_NODATA, "4");
1243       log_error (_("no signature found\n"));
1244       rc = gpg_error (GPG_ERR_NO_DATA);
1245     }
1246
1247   /* Propagate the signature seen flag upward. Do this only on success
1248      so that we won't issue the nodata status several times. */
1249   if (!rc && c->anchor && c->any.sig_seen)
1250     c->anchor->any.sig_seen = 1;
1251
1252   xfree ( c );
1253   return rc;
1254 }
1255
1256
1257 int
1258 proc_encryption_packets (ctrl_t ctrl, void *anchor, iobuf_t a )
1259 {
1260   CTX c = xmalloc_clear (sizeof *c);
1261   int rc;
1262
1263   c->ctrl = ctrl;
1264   c->anchor = anchor;
1265   c->encrypt_only = 1;
1266   rc = do_proc_packets (c, a);
1267   xfree (c);
1268   return rc;
1269 }
1270
1271
1272 static int
1273 check_nesting (CTX c)
1274 {
1275   int level;
1276
1277   for (level=0; c; c = c->anchor)
1278     level++;
1279
1280   if (level > MAX_NESTING_DEPTH)
1281     {
1282       log_error ("input data with too deeply nested packets\n");
1283       write_status_text (STATUS_UNEXPECTED, "1");
1284       return GPG_ERR_BAD_DATA;
1285     }
1286
1287   return 0;
1288 }
1289
1290
1291 static int
1292 do_proc_packets (CTX c, iobuf_t a)
1293 {
1294   PACKET *pkt;
1295   int rc = 0;
1296   int any_data = 0;
1297   int newpkt;
1298
1299   rc = check_nesting (c);
1300   if (rc)
1301     return rc;
1302
1303   pkt = xmalloc( sizeof *pkt );
1304   c->iobuf = a;
1305   init_packet(pkt);
1306   while ((rc=parse_packet(a, pkt)) != -1)
1307     {
1308       any_data = 1;
1309       if (rc)
1310         {
1311           free_packet (pkt);
1312           /* Stop processing when an invalid packet has been encountered
1313            * but don't do so when we are doing a --list-packets.  */
1314           if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
1315               && opt.list_packets != 2 )
1316             break;
1317           continue;
1318         }
1319       newpkt = -1;
1320       if (opt.list_packets)
1321         {
1322           switch (pkt->pkttype)
1323             {
1324             case PKT_PUBKEY_ENC:    proc_pubkey_enc (c, pkt); break;
1325             case PKT_SYMKEY_ENC:    proc_symkey_enc (c, pkt); break;
1326             case PKT_ENCRYPTED:
1327             case PKT_ENCRYPTED_MDC: proc_encrypted (c, pkt); break;
1328             case PKT_COMPRESSED:    rc = proc_compressed (c, pkt); break;
1329             default: newpkt = 0; break;
1330             }
1331         }
1332       else if (c->sigs_only)
1333         {
1334           switch (pkt->pkttype)
1335             {
1336             case PKT_PUBLIC_KEY:
1337             case PKT_SECRET_KEY:
1338             case PKT_USER_ID:
1339             case PKT_SYMKEY_ENC:
1340             case PKT_PUBKEY_ENC:
1341             case PKT_ENCRYPTED:
1342             case PKT_ENCRYPTED_MDC:
1343               write_status_text( STATUS_UNEXPECTED, "0" );
1344               rc = GPG_ERR_UNEXPECTED;
1345               goto leave;
1346
1347             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1348             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1349             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1350             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1351             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1352             default: newpkt = 0; break;
1353             }
1354         }
1355       else if (c->encrypt_only)
1356         {
1357           switch (pkt->pkttype)
1358             {
1359             case PKT_PUBLIC_KEY:
1360             case PKT_SECRET_KEY:
1361             case PKT_USER_ID:
1362               write_status_text (STATUS_UNEXPECTED, "0");
1363               rc = GPG_ERR_UNEXPECTED;
1364               goto leave;
1365
1366             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1367             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1368             case PKT_PUBKEY_ENC:  proc_pubkey_enc (c, pkt); break;
1369             case PKT_ENCRYPTED:
1370             case PKT_ENCRYPTED_MDC: proc_encrypted (c, pkt); break;
1371             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1372             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1373             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1374             case PKT_GPG_CONTROL: newpkt = add_gpg_control (c, pkt); break;
1375             default: newpkt = 0; break;
1376             }
1377         }
1378       else
1379         {
1380           switch (pkt->pkttype)
1381             {
1382             case PKT_PUBLIC_KEY:
1383             case PKT_SECRET_KEY:
1384               release_list (c);
1385               c->list = new_kbnode (pkt);
1386               newpkt = 1;
1387               break;
1388             case PKT_PUBLIC_SUBKEY:
1389             case PKT_SECRET_SUBKEY:
1390               newpkt = add_subkey (c, pkt);
1391               break;
1392             case PKT_USER_ID:     newpkt = add_user_id (c, pkt); break;
1393             case PKT_SIGNATURE:   newpkt = add_signature (c, pkt); break;
1394             case PKT_PUBKEY_ENC:  proc_pubkey_enc (c, pkt); break;
1395             case PKT_SYMKEY_ENC:  proc_symkey_enc (c, pkt); break;
1396             case PKT_ENCRYPTED:
1397             case PKT_ENCRYPTED_MDC: proc_encrypted (c, pkt); break;
1398             case PKT_PLAINTEXT:   proc_plaintext (c, pkt); break;
1399             case PKT_COMPRESSED:  rc = proc_compressed (c, pkt); break;
1400             case PKT_ONEPASS_SIG: newpkt = add_onepass_sig (c, pkt); break;
1401             case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1402             case PKT_RING_TRUST:  newpkt = add_ring_trust (c, pkt); break;
1403             default: newpkt = 0; break;
1404             }
1405         }
1406
1407       if (rc)
1408         goto leave;
1409
1410       /* This is a very ugly construct and frankly, I don't remember why
1411        * I used it.  Adding the MDC check here is a hack.
1412        * The right solution is to initiate another context for encrypted
1413        * packet and not to reuse the current one ...  It works right
1414        * when there is a compression packet inbetween which adds just
1415        * an extra layer.
1416        * Hmmm: Rewrite this whole module here??
1417        */
1418       if (pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC)
1419         c->any.data = (pkt->pkttype == PKT_PLAINTEXT);
1420
1421       if (newpkt == -1)
1422         ;
1423       else if (newpkt)
1424         {
1425           pkt = xmalloc (sizeof *pkt);
1426           init_packet (pkt);
1427         }
1428       else
1429         free_packet(pkt);
1430     }
1431
1432   if (rc == GPG_ERR_INV_PACKET)
1433     write_status_text (STATUS_NODATA, "3");
1434
1435   if (any_data)
1436     rc = 0;
1437   else if (rc == -1)
1438     write_status_text (STATUS_NODATA, "2");
1439
1440
1441  leave:
1442   release_list (c);
1443   xfree(c->dek);
1444   free_packet (pkt);
1445   xfree (pkt);
1446   free_md_filter_context (&c->mfx);
1447   return rc;
1448 }
1449
1450
1451 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1452    of the notation data. */
1453 static pka_info_t *
1454 get_pka_address (PKT_signature *sig)
1455 {
1456   pka_info_t *pka = NULL;
1457   struct notation *nd,*notation;
1458
1459   notation=sig_to_notation(sig);
1460
1461   for(nd=notation;nd;nd=nd->next)
1462     {
1463       if(strcmp(nd->name,"pka-address@gnupg.org")!=0)
1464         continue; /* Not the notation we want. */
1465
1466       /* For now we only use the first valid PKA notation. In future
1467          we might want to keep additional PKA notations in a linked
1468          list. */
1469       if (is_valid_mailbox (nd->value))
1470         {
1471           pka = xmalloc (sizeof *pka + strlen(nd->value));
1472           pka->valid = 0;
1473           pka->checked = 0;
1474           pka->uri = NULL;
1475           strcpy (pka->email, nd->value);
1476           break;
1477         }
1478     }
1479
1480   free_notation(notation);
1481
1482   return pka;
1483 }
1484
1485
1486 /* Return the URI from a DNS PKA record.  If this record has already
1487    be retrieved for the signature we merely return it; if not we go
1488    out and try to get that DNS record. */
1489 static const char *
1490 pka_uri_from_sig (PKT_signature *sig)
1491 {
1492   if (!sig->flags.pka_tried)
1493     {
1494       assert (!sig->pka_info);
1495       sig->flags.pka_tried = 1;
1496       sig->pka_info = get_pka_address (sig);
1497       if (sig->pka_info)
1498         {
1499           char *uri;
1500
1501           uri = get_pka_info (sig->pka_info->email,
1502                               sig->pka_info->fpr, sizeof sig->pka_info->fpr);
1503           if (uri)
1504             {
1505               sig->pka_info->valid = 1;
1506               if (!*uri)
1507                 xfree (uri);
1508               else
1509                 sig->pka_info->uri = uri;
1510             }
1511         }
1512     }
1513   return sig->pka_info? sig->pka_info->uri : NULL;
1514 }
1515
1516
1517 static void
1518 print_good_bad_signature (int statno, const char *keyid_str, kbnode_t un,
1519                           PKT_signature *sig, int rc)
1520 {
1521   char *p;
1522
1523   write_status_text_and_buffer (statno, keyid_str,
1524                                 un? un->pkt->pkt.user_id->name:"[?]",
1525                                 un? un->pkt->pkt.user_id->len:3,
1526                                 -1);
1527
1528   if (un)
1529     p = utf8_to_native (un->pkt->pkt.user_id->name,
1530                         un->pkt->pkt.user_id->len, 0);
1531   else
1532     p = xstrdup ("[?]");
1533
1534   if (rc)
1535     log_info (_("BAD signature from \"%s\""), p);
1536   else if (sig->flags.expired)
1537     log_info (_("Expired signature from \"%s\""), p);
1538   else
1539     log_info (_("Good signature from \"%s\""), p);
1540
1541   xfree (p);
1542 }
1543
1544
1545 static int
1546 check_sig_and_print (CTX c, kbnode_t node)
1547 {
1548   PKT_signature *sig = node->pkt->pkt.signature;
1549   const char *astr;
1550   int rc;
1551   int is_expkey = 0;
1552   int is_revkey = 0;
1553   char pkstrbuf[PUBKEY_STRING_SIZE];
1554
1555   *pkstrbuf = 0;
1556
1557   if (opt.skip_verify)
1558     {
1559       log_info(_("signature verification suppressed\n"));
1560       return 0;
1561     }
1562
1563   /* Check that the message composition is valid.
1564
1565      Per RFC-2440bis (-15) allowed:
1566
1567      S{1,n}           -- detached signature.
1568      S{1,n} P         -- old style PGP2 signature
1569      O{1,n} P S{1,n}  -- standard OpenPGP signature.
1570      C P S{1,n}       -- cleartext signature.
1571
1572
1573           O = One-Pass Signature packet.
1574           S = Signature packet.
1575           P = OpenPGP Message packet (Encrypted | Compressed | Literal)
1576                  (Note that the current rfc2440bis draft also allows
1577                   for a signed message but that does not work as it
1578                   introduces ambiguities.)
1579               We keep track of these packages using the marker packet
1580               CTRLPKT_PLAINTEXT_MARK.
1581           C = Marker packet for cleartext signatures.
1582
1583      We reject all other messages.
1584
1585      Actually we are calling this too often, i.e. for verification of
1586      each message but better have some duplicate work than to silently
1587      introduce a bug here.
1588   */
1589   {
1590     kbnode_t n;
1591     int n_onepass, n_sig;
1592
1593 /*     log_debug ("checking signature packet composition\n"); */
1594 /*     dump_kbnode (c->list); */
1595
1596     n = c->list;
1597     assert (n);
1598     if ( n->pkt->pkttype == PKT_SIGNATURE )
1599       {
1600         /* This is either "S{1,n}" case (detached signature) or
1601            "S{1,n} P" (old style PGP2 signature). */
1602         for (n = n->next; n; n = n->next)
1603           if (n->pkt->pkttype != PKT_SIGNATURE)
1604             break;
1605         if (!n)
1606           ; /* Okay, this is a detached signature.  */
1607         else if (n->pkt->pkttype == PKT_GPG_CONTROL
1608                  && (n->pkt->pkt.gpg_control->control
1609                      == CTRLPKT_PLAINTEXT_MARK) )
1610           {
1611             if (n->next)
1612               goto ambiguous;  /* We only allow one P packet. */
1613           }
1614         else
1615           goto ambiguous;
1616       }
1617     else if (n->pkt->pkttype == PKT_ONEPASS_SIG)
1618       {
1619         /* This is the "O{1,n} P S{1,n}" case (standard signature). */
1620         for (n_onepass=1, n = n->next;
1621              n && n->pkt->pkttype == PKT_ONEPASS_SIG; n = n->next)
1622           n_onepass++;
1623         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1624                     && (n->pkt->pkt.gpg_control->control
1625                         == CTRLPKT_PLAINTEXT_MARK)))
1626           goto ambiguous;
1627         for (n_sig=0, n = n->next;
1628              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1629           n_sig++;
1630         if (!n_sig)
1631           goto ambiguous;
1632
1633         /* If we wanted to disallow multiple sig verification, we'd do
1634            something like this:
1635
1636            if (n && !opt.allow_multisig_verification)
1637              goto ambiguous;
1638
1639            However, now that we have --allow-multiple-messages, this
1640            can stay allowable as we can't get here unless multiple
1641            messages (i.e. multiple literals) are allowed. */
1642
1643         if (n_onepass != n_sig)
1644           {
1645             log_info ("number of one-pass packets does not match "
1646                       "number of signature packets\n");
1647             goto ambiguous;
1648           }
1649       }
1650     else if (n->pkt->pkttype == PKT_GPG_CONTROL
1651              && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
1652       {
1653         /* This is the "C P S{1,n}" case (clear text signature). */
1654         n = n->next;
1655         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1656                     && (n->pkt->pkt.gpg_control->control
1657                         == CTRLPKT_PLAINTEXT_MARK)))
1658           goto ambiguous;
1659         for (n_sig=0, n = n->next;
1660              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1661           n_sig++;
1662         if (n || !n_sig)
1663           goto ambiguous;
1664       }
1665     else
1666       {
1667       ambiguous:
1668         log_error(_("can't handle this ambiguous signature data\n"));
1669         return 0;
1670       }
1671   }
1672
1673   astr = openpgp_pk_algo_name ( sig->pubkey_algo );
1674   if (keystrlen () > 8)
1675     {
1676       log_info (_("Signature made %s\n"), asctimestamp(sig->timestamp));
1677       log_info (_("               using %s key %s\n"),
1678                 astr? astr: "?",keystr(sig->keyid));
1679     }
1680   else
1681     log_info (_("Signature made %s using %s key ID %s\n"),
1682               asctimestamp(sig->timestamp), astr? astr: "?",
1683               keystr(sig->keyid));
1684
1685   rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey );
1686
1687   /* If the key isn't found, check for a preferred keyserver */
1688
1689   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY && sig->flags.pref_ks)
1690     {
1691       const byte *p;
1692       int seq = 0;
1693       size_t n;
1694
1695       while ((p=enum_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1696         {
1697           /* According to my favorite copy editor, in English grammar,
1698              you say "at" if the key is located on a web page, but
1699              "from" if it is located on a keyserver.  I'm not going to
1700              even try to make two strings here :) */
1701           log_info(_("Key available at: ") );
1702           print_utf8_buffer (log_get_stream(), p, n);
1703           log_printf ("\n");
1704
1705           if (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1706               && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1707             {
1708               struct keyserver_spec *spec;
1709
1710               spec = parse_preferred_keyserver (sig);
1711               if (spec)
1712                 {
1713                   int res;
1714
1715                   glo_ctrl.in_auto_key_retrieve++;
1716                   res = keyserver_import_keyid (c->ctrl, sig->keyid,spec);
1717                   glo_ctrl.in_auto_key_retrieve--;
1718                   if (!res)
1719                     rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1720                   free_keyserver_spec (spec);
1721
1722                   if (!rc)
1723                     break;
1724                 }
1725             }
1726         }
1727     }
1728
1729   /* If the preferred keyserver thing above didn't work, our second
1730      try is to use the URI from a DNS PKA record. */
1731   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1732       && (opt.keyserver_options.options & KEYSERVER_AUTO_KEY_RETRIEVE)
1733       && (opt.keyserver_options.options & KEYSERVER_HONOR_PKA_RECORD))
1734     {
1735       const char *uri = pka_uri_from_sig (sig);
1736
1737       if (uri)
1738         {
1739           /* FIXME: We might want to locate the key using the
1740              fingerprint instead of the keyid. */
1741           int res;
1742           struct keyserver_spec *spec;
1743
1744           spec = parse_keyserver_uri (uri, 1);
1745           if (spec)
1746             {
1747               glo_ctrl.in_auto_key_retrieve++;
1748               res = keyserver_import_keyid (c->ctrl, sig->keyid, spec);
1749                 glo_ctrl.in_auto_key_retrieve--;
1750                 free_keyserver_spec (spec);
1751                 if (!res)
1752                   rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey );
1753             }
1754         }
1755     }
1756
1757   /* If the preferred keyserver thing above didn't work and we got
1758        no information from the DNS PKA, this is a third try. */
1759
1760   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1761       && opt.keyserver
1762       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE))
1763     {
1764       int res;
1765
1766       glo_ctrl.in_auto_key_retrieve++;
1767       res=keyserver_import_keyid (c->ctrl, sig->keyid, opt.keyserver );
1768       glo_ctrl.in_auto_key_retrieve--;
1769       if (!res)
1770         rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey );
1771     }
1772
1773   if (!rc || gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
1774     {
1775       kbnode_t un, keyblock;
1776       int count = 0;
1777       int statno;
1778       char keyid_str[50];
1779       PKT_public_key *pk = NULL;
1780
1781       if (rc)
1782         statno = STATUS_BADSIG;
1783       else if (sig->flags.expired)
1784         statno = STATUS_EXPSIG;
1785       else if (is_expkey)
1786         statno = STATUS_EXPKEYSIG;
1787       else if(is_revkey)
1788         statno = STATUS_REVKEYSIG;
1789       else
1790         statno = STATUS_GOODSIG;
1791
1792       keyblock = get_pubkeyblock (sig->keyid);
1793
1794       snprintf (keyid_str, sizeof keyid_str, "%08lX%08lX [uncertain] ",
1795                 (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1796
1797       /* Find and print the primary user ID.  */
1798       for (un=keyblock; un; un = un->next)
1799         {
1800           int valid;
1801
1802           if (un->pkt->pkttype==PKT_PUBLIC_KEY)
1803             {
1804               pk=un->pkt->pkt.public_key;
1805               continue;
1806             }
1807           if (un->pkt->pkttype != PKT_USER_ID)
1808             continue;
1809           if (!un->pkt->pkt.user_id->created)
1810             continue;
1811           if (un->pkt->pkt.user_id->is_revoked)
1812             continue;
1813           if (un->pkt->pkt.user_id->is_expired)
1814             continue;
1815           if (!un->pkt->pkt.user_id->is_primary)
1816             continue;
1817           /* We want the textual primary user ID here */
1818           if (un->pkt->pkt.user_id->attrib_data)
1819             continue;
1820
1821           assert (pk);
1822
1823           /* Get it before we print anything to avoid interrupting the
1824              output with the "please do a --check-trustdb" line. */
1825           valid = get_validity (pk, un->pkt->pkt.user_id);
1826
1827           keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1828
1829           print_good_bad_signature (statno, keyid_str, un, sig, rc);
1830
1831           if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
1832             log_printf (" [%s]\n",trust_value_to_string(valid));
1833           else
1834             log_printf ("\n");
1835
1836           pubkey_string (pk, pkstrbuf, sizeof pkstrbuf);
1837           count++;
1838         }
1839
1840       if (!count)  /* Just in case that we have no valid textual userid */
1841         {
1842           /* Try for an invalid textual userid */
1843           for (un=keyblock; un; un = un->next)
1844             {
1845               if (un->pkt->pkttype == PKT_USER_ID
1846                   && !un->pkt->pkt.user_id->attrib_data)
1847                 break;
1848             }
1849
1850           /* Try for any userid at all */
1851           if (!un)
1852             {
1853               for (un=keyblock; un; un = un->next)
1854                 {
1855                   if (un->pkt->pkttype == PKT_USER_ID)
1856                     break;
1857                 }
1858             }
1859
1860           if (opt.trust_model==TM_ALWAYS || !un)
1861             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1862
1863           print_good_bad_signature (statno, keyid_str, un, sig, rc);
1864
1865           if (opt.trust_model != TM_ALWAYS && un)
1866             log_printf (" %s",_("[uncertain]") );
1867           log_printf ("\n");
1868         }
1869
1870       /* If we have a good signature and already printed
1871        * the primary user ID, print all the other user IDs */
1872       if (count
1873           && !rc
1874           && !(opt.verify_options & VERIFY_SHOW_PRIMARY_UID_ONLY))
1875         {
1876           char *p;
1877           for( un=keyblock; un; un = un->next)
1878             {
1879               if (un->pkt->pkttype != PKT_USER_ID)
1880                 continue;
1881               if ((un->pkt->pkt.user_id->is_revoked
1882                    || un->pkt->pkt.user_id->is_expired)
1883                   && !(opt.verify_options & VERIFY_SHOW_UNUSABLE_UIDS))
1884                 continue;
1885               /* Only skip textual primaries */
1886               if (un->pkt->pkt.user_id->is_primary
1887                   && !un->pkt->pkt.user_id->attrib_data )
1888                 continue;
1889
1890               if (un->pkt->pkt.user_id->attrib_data)
1891                 {
1892                   dump_attribs (un->pkt->pkt.user_id, pk);
1893
1894                   if (opt.verify_options&VERIFY_SHOW_PHOTOS)
1895                     show_photos (un->pkt->pkt.user_id->attribs,
1896                                  un->pkt->pkt.user_id->numattribs,
1897                                  pk ,un->pkt->pkt.user_id);
1898                 }
1899
1900               p = utf8_to_native (un->pkt->pkt.user_id->name,
1901                                   un->pkt->pkt.user_id->len, 0);
1902               log_info (_("                aka \"%s\""), p);
1903               xfree (p);
1904
1905               if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
1906                 {
1907                   const char *valid;
1908
1909                   if (un->pkt->pkt.user_id->is_revoked)
1910                     valid = _("revoked");
1911                   else if (un->pkt->pkt.user_id->is_expired)
1912                     valid = _("expired");
1913                   else
1914                     valid = (trust_value_to_string
1915                              (get_validity (pk, un->pkt->pkt.user_id)));
1916                   log_printf (" [%s]\n",valid);
1917                 }
1918               else
1919                 log_printf ("\n");
1920             }
1921         }
1922       release_kbnode( keyblock );
1923
1924       if (!rc)
1925         {
1926           if ((opt.verify_options & VERIFY_SHOW_POLICY_URLS))
1927             show_policy_url (sig, 0, 1);
1928           else
1929             show_policy_url (sig, 0, 2);
1930
1931           if ((opt.verify_options & VERIFY_SHOW_KEYSERVER_URLS))
1932             show_keyserver_url (sig, 0, 1);
1933           else
1934             show_keyserver_url (sig, 0, 2);
1935
1936           if ((opt.verify_options & VERIFY_SHOW_NOTATIONS))
1937             show_notation
1938               (sig, 0, 1,
1939                (((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)
1940                 + ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0)));
1941           else
1942             show_notation (sig, 0, 2, 0);
1943         }
1944
1945       if (!rc && is_status_enabled ())
1946         {
1947           /* Print a status response with the fingerprint. */
1948           PKT_public_key *vpk = xmalloc_clear (sizeof *vpk);
1949
1950           if (!get_pubkey (vpk, sig->keyid))
1951             {
1952               byte array[MAX_FINGERPRINT_LEN], *p;
1953               char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1954               size_t i, n;
1955
1956               bufp = buf;
1957               fingerprint_from_pk (vpk, array, &n);
1958               p = array;
1959               for(i=0; i < n ; i++, p++, bufp += 2)
1960                 sprintf (bufp, "%02X", *p );
1961               /* TODO: Replace the reserved '0' in the field below
1962                  with bits for status flags (policy url, notation,
1963                  etc.).  Remember to make the buffer larger to match! */
1964               sprintf (bufp, " %s %lu %lu %d 0 %d %d %02X ",
1965                        strtimestamp( sig->timestamp ),
1966                        (ulong)sig->timestamp,(ulong)sig->expiredate,
1967                        sig->version,sig->pubkey_algo,sig->digest_algo,
1968                        sig->sig_class);
1969               bufp = bufp + strlen (bufp);
1970               if (!vpk->flags.primary)
1971                 {
1972                   u32 akid[2];
1973
1974                   akid[0] = vpk->main_keyid[0];
1975                   akid[1] = vpk->main_keyid[1];
1976                   free_public_key (vpk);
1977                   vpk = xmalloc_clear (sizeof *vpk);
1978                   if (get_pubkey (vpk, akid))
1979                     {
1980                       /* Impossible error, we simply return a zeroed out fpr */
1981                       n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1982                       memset (array, 0, n);
1983                     }
1984                   else
1985                     fingerprint_from_pk( vpk, array, &n );
1986                 }
1987               p = array;
1988               for (i=0; i < n ; i++, p++, bufp += 2)
1989                 sprintf(bufp, "%02X", *p );
1990               write_status_text (STATUS_VALIDSIG, buf);
1991             }
1992           free_public_key (vpk);
1993         }
1994
1995       if (!rc)
1996         {
1997           if ((opt.verify_options & VERIFY_PKA_LOOKUPS))
1998             pka_uri_from_sig (sig); /* Make sure PKA info is available. */
1999           rc = check_signatures_trust (sig);
2000         }
2001
2002       if (sig->flags.expired)
2003         {
2004           log_info (_("Signature expired %s\n"), asctimestamp(sig->expiredate));
2005           rc = GPG_ERR_GENERAL; /* Need a better error here?  */
2006         }
2007       else if (sig->expiredate)
2008         log_info (_("Signature expires %s\n"), asctimestamp(sig->expiredate));
2009
2010       if (opt.verbose)
2011         log_info (_("%s signature, digest algorithm %s%s%s\n"),
2012                   sig->sig_class==0x00?_("binary"):
2013                   sig->sig_class==0x01?_("textmode"):_("unknown"),
2014                   gcry_md_algo_name (sig->digest_algo),
2015                   *pkstrbuf?_(", key algorithm "):"",
2016                   pkstrbuf);
2017
2018       if (!rc && !c->signed_data.used)
2019         {
2020           /* Signature is basically good but we test whether the
2021              deprecated command
2022                gpg --verify FILE.sig
2023              was used instead of
2024                gpg --verify FILE.sig FILE
2025              to verify a detached signature.  If we figure out that a
2026              data file with a matching name exists, we print a warning.
2027
2028              The problem is that the first form would also verify a
2029              standard signature.  This behavior could be used to
2030              create a made up .sig file for a tarball by creating a
2031              standard signature from a valid detached signature packet
2032              (for example from a signed git tag).  Then replace the
2033              sig file on the FTP server along with a changed tarball.
2034              Using the first form the verify command would correctly
2035              verify the signature but don't even consider the tarball.  */
2036           kbnode_t n;
2037           char *dfile;
2038
2039           dfile = get_matching_datafile (c->sigfilename);
2040           if (dfile)
2041             {
2042               for (n = c->list; n; n = n->next)
2043                 if (n->pkt->pkttype != PKT_SIGNATURE)
2044                   break;
2045               if (n)
2046                 {
2047                   /* Not only signature packets in the tree thus this
2048                      is not a detached signature.  */
2049                   log_info (_("WARNING: not a detached signature; "
2050                               "file '%s' was NOT verified!\n"), dfile);
2051                 }
2052               xfree (dfile);
2053             }
2054         }
2055
2056       if (rc)
2057         g10_errors_seen = 1;
2058       if (opt.batch && rc)
2059         g10_exit (1);
2060     }
2061   else
2062     {
2063       char buf[50];
2064
2065       snprintf (buf, sizeof buf, "%08lX%08lX %d %d %02x %lu %d",
2066                 (ulong)sig->keyid[0], (ulong)sig->keyid[1],
2067                 sig->pubkey_algo, sig->digest_algo,
2068                 sig->sig_class, (ulong)sig->timestamp, rc);
2069       write_status_text (STATUS_ERRSIG, buf);
2070       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
2071         {
2072           buf[16] = 0;
2073           write_status_text (STATUS_NO_PUBKEY, buf);
2074         }
2075       if (gpg_err_code (rc) != GPG_ERR_NOT_PROCESSED)
2076         log_error (_("Can't check signature: %s\n"), gpg_strerror (rc));
2077     }
2078
2079   return rc;
2080 }
2081
2082
2083 /*
2084  * Process the tree which starts at node
2085  */
2086 static void
2087 proc_tree (CTX c, kbnode_t node)
2088 {
2089   kbnode_t n1;
2090   int rc;
2091
2092   if (opt.list_packets || opt.list_only)
2093     return;
2094
2095   /* We must skip our special plaintext marker packets here because
2096      they may be the root packet.  These packets are only used in
2097      addional checks and skipping them here doesn't matter.  */
2098   while (node
2099          && node->pkt->pkttype == PKT_GPG_CONTROL
2100           && node->pkt->pkt.gpg_control->control == CTRLPKT_PLAINTEXT_MARK)
2101     {
2102       node = node->next;
2103     }
2104   if (!node)
2105     return;
2106
2107   c->trustletter = ' ';
2108   if (node->pkt->pkttype == PKT_PUBLIC_KEY
2109       || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2110     {
2111       merge_keys_and_selfsig (node);
2112       list_node (c, node);
2113     }
2114   else if (node->pkt->pkttype == PKT_SECRET_KEY)
2115     {
2116       merge_keys_and_selfsig (node);
2117       list_node (c, node);
2118     }
2119   else if (node->pkt->pkttype == PKT_ONEPASS_SIG)
2120     {
2121       /* Check all signatures.  */
2122       if (!c->any.data)
2123         {
2124           int use_textmode = 0;
2125
2126           free_md_filter_context (&c->mfx);
2127           /* Prepare to create all requested message digests.  */
2128           rc = gcry_md_open (&c->mfx.md, 0, 0);
2129           if (rc)
2130             goto hash_err;
2131
2132           /* Fixme: why looking for the signature packet and not the
2133              one-pass packet?  */
2134           for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2135             gcry_md_enable (c->mfx.md, n1->pkt->pkt.signature->digest_algo);
2136
2137           if (n1 && n1->pkt->pkt.onepass_sig->sig_class == 0x01)
2138             use_textmode = 1;
2139
2140           /* Ask for file and hash it. */
2141           if (c->sigs_only)
2142             {
2143               if (c->signed_data.used && c->signed_data.data_fd != -1)
2144                 rc = hash_datafile_by_fd (c->mfx.md, NULL,
2145                                           c->signed_data.data_fd,
2146                                           use_textmode);
2147               else
2148                 rc = hash_datafiles (c->mfx.md, NULL,
2149                                      c->signed_data.data_names,
2150                                      c->sigfilename,
2151                                      use_textmode);
2152             }
2153           else
2154             {
2155               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2156                                               iobuf_get_real_fname (c->iobuf),
2157                                               use_textmode);
2158             }
2159
2160         hash_err:
2161           if (rc)
2162             {
2163               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2164               return;
2165             }
2166         }
2167       else if (c->signed_data.used)
2168         {
2169           log_error (_("not a detached signature\n"));
2170           return;
2171         }
2172
2173       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2174         check_sig_and_print (c, n1);
2175
2176     }
2177   else if (node->pkt->pkttype == PKT_GPG_CONTROL
2178            && node->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START)
2179     {
2180       /* Clear text signed message.  */
2181       if (!c->any.data)
2182         {
2183           log_error ("cleartext signature without data\n");
2184           return;
2185         }
2186       else if (c->signed_data.used)
2187         {
2188           log_error (_("not a detached signature\n"));
2189           return;
2190         }
2191
2192       for (n1 = node; (n1 = find_next_kbnode (n1, PKT_SIGNATURE));)
2193         check_sig_and_print (c, n1);
2194
2195     }
2196   else if (node->pkt->pkttype == PKT_SIGNATURE)
2197     {
2198       PKT_signature *sig = node->pkt->pkt.signature;
2199       int multiple_ok = 1;
2200
2201       n1 = find_next_kbnode (node, PKT_SIGNATURE);
2202       if (n1)
2203         {
2204           byte class = sig->sig_class;
2205           byte hash  = sig->digest_algo;
2206
2207           for (; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2208             {
2209               /* We can't currently handle multiple signatures of
2210                  different classes or digests (we'd pretty much have
2211                  to run a different hash context for each), but if
2212                  they are all the same, make an exception. */
2213               if (n1->pkt->pkt.signature->sig_class != class
2214                   || n1->pkt->pkt.signature->digest_algo != hash)
2215                 {
2216                   multiple_ok = 0;
2217                   log_info (_("WARNING: multiple signatures detected.  "
2218                               "Only the first will be checked.\n"));
2219                   break;
2220                 }
2221             }
2222         }
2223
2224       if (sig->sig_class != 0x00 && sig->sig_class != 0x01)
2225         {
2226           log_info(_("standalone signature of class 0x%02x\n"), sig->sig_class);
2227         }
2228       else if (!c->any.data)
2229         {
2230           /* Detached signature */
2231           free_md_filter_context (&c->mfx);
2232           rc = gcry_md_open (&c->mfx.md, sig->digest_algo, 0);
2233           if (rc)
2234             goto detached_hash_err;
2235
2236           if (RFC2440 || RFC4880)
2237             ; /* Strict RFC mode.  */
2238           else if (sig->digest_algo == DIGEST_ALGO_SHA1
2239                    && sig->pubkey_algo == PUBKEY_ALGO_DSA
2240                    && sig->sig_class == 0x01)
2241             {
2242               /* Enable a workaround for a pgp5 bug when the detached
2243                * signature has been created in textmode.  */
2244               rc = gcry_md_open (&c->mfx.md2, sig->digest_algo, 0);
2245               if (rc)
2246                 goto detached_hash_err;
2247             }
2248
2249           /* Here we used to have another hack to work around a pgp
2250            * 2 bug: It worked by not using the textmode for detached
2251            * signatures; this would let the first signature check
2252            * (on md) fail but the second one (on md2), which adds an
2253            * extra CR would then have produced the "correct" hash.
2254            * This is very, very ugly hack but it may haved help in
2255            * some cases (and break others).
2256            *     c->mfx.md2? 0 :(sig->sig_class == 0x01)
2257            */
2258
2259           if (DBG_HASHING)
2260             {
2261               gcry_md_debug (c->mfx.md, "verify");
2262               if (c->mfx.md2)
2263                 gcry_md_debug (c->mfx.md2, "verify2");
2264             }
2265
2266           if (c->sigs_only)
2267             {
2268               if (c->signed_data.used && c->signed_data.data_fd != -1)
2269                 rc = hash_datafile_by_fd (c->mfx.md, c->mfx.md2,
2270                                           c->signed_data.data_fd,
2271                                           (sig->sig_class == 0x01));
2272               else
2273                 rc = hash_datafiles (c->mfx.md, c->mfx.md2,
2274                                      c->signed_data.data_names,
2275                                      c->sigfilename,
2276                                      (sig->sig_class == 0x01));
2277             }
2278           else
2279             {
2280               rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2281                                               iobuf_get_real_fname(c->iobuf),
2282                                               (sig->sig_class == 0x01));
2283             }
2284
2285         detached_hash_err:
2286           if (rc)
2287             {
2288               log_error ("can't hash datafile: %s\n", gpg_strerror (rc));
2289               return;
2290             }
2291         }
2292       else if (c->signed_data.used)
2293         {
2294           log_error (_("not a detached signature\n"));
2295           return;
2296         }
2297       else if (!opt.quiet)
2298         log_info (_("old style (PGP 2.x) signature\n"));
2299
2300       if (multiple_ok)
2301         {
2302           for (n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2303             check_sig_and_print (c, n1);
2304         }
2305       else
2306         check_sig_and_print (c, node);
2307
2308     }
2309   else
2310     {
2311       dump_kbnode (c->list);
2312       log_error ("invalid root packet detected in proc_tree()\n");
2313       dump_kbnode (node);
2314     }
2315 }