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