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