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