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