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