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