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