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