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