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