87e99126aeca1d0c4759f6cfcfb92a0a83050467
[gnupg.git] / g10 / mainproc.c
1 /* mainproc.c - handle packets
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2009 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <time.h>
27
28 #include "gpg.h"
29 #include "packet.h"
30 #include "iobuf.h"
31 #include "options.h"
32 #include "util.h"
33 #include "cipher.h"
34 #include "keydb.h"
35 #include "filter.h"
36 #include "main.h"
37 #include "status.h"
38 #include "i18n.h"
39 #include "trustdb.h"
40 #include "keyserver-internal.h"
41 #include "photoid.h"
42 #include "pka.h"
43
44
45 struct kidlist_item {
46     struct kidlist_item *next;
47     u32 kid[2];
48     int pubkey_algo;
49     int reason;
50 };
51
52
53 /****************
54  * Structure to hold the context
55  */
56 typedef struct mainproc_context *CTX;
57 struct mainproc_context
58 {
59   struct mainproc_context *anchor;  /* May be useful in the future. */
60   PKT_public_key *last_pubkey;
61   PKT_secret_key *last_seckey;
62   PKT_user_id     *last_user_id;
63   md_filter_context_t mfx;
64   int sigs_only;    /* Process only signatures and reject all other stuff. */
65   int encrypt_only; /* Process only encryption messages. */
66     
67   /* Name of the file with the complete signature or the file with the
68      detached signature.  This is currently only used to deduce the
69      file name of the data file if that has not been given. */
70   const char *sigfilename;
71   
72   /* A structure to describe the signed data in case of a detached
73      signature. */
74   struct 
75   {
76     /* A file descriptor of the the signed data.  Only used if not -1. */
77     int data_fd;
78     /* A list of filenames with the data files or NULL. This is only
79        used if DATA_FD is -1. */
80     strlist_t data_names;
81     /* Flag to indicated that either one of the next previous 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, 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 (info, a,
762                                          ((CTX)info)->signed_data.data_fd);
763   else
764     return proc_signature_packets (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     return proc_encryption_packets( info, a );
773 }
774
775 static void
776 proc_compressed( CTX c, PACKET *pkt )
777 {
778     PKT_compressed *zd = pkt->pkt.compressed;
779     int rc;
780
781     /*printf("zip: compressed data packet\n");*/
782     if( !zd->algorithm )
783       rc=G10ERR_COMPR_ALGO;
784     else if( c->sigs_only )
785         rc = handle_compressed( c, zd, proc_compressed_cb, c );
786     else if( c->encrypt_only )
787         rc = handle_compressed( c, zd, proc_encrypt_cb, c );
788     else
789         rc = handle_compressed( c, zd, NULL, NULL );
790     if( rc )
791         log_error("uncompressing failed: %s\n", g10_errstr(rc));
792     free_packet(pkt);
793     c->last_was_session_key = 0;
794 }
795
796 /****************
797  * check the signature
798  * Returns: 0 = valid signature or an error code
799  */
800 static int
801 do_check_sig( CTX c, KBNODE node, int *is_selfsig,
802               int *is_expkey, int *is_revkey )
803 {
804     PKT_signature *sig;
805     gcry_md_hd_t md = NULL, md2 = NULL;
806     int algo, rc;
807
808     assert( node->pkt->pkttype == PKT_SIGNATURE );
809     if( is_selfsig )
810         *is_selfsig = 0;
811     sig = node->pkt->pkt.signature;
812
813     algo = sig->digest_algo;
814     rc = openpgp_md_test_algo(algo);
815     if (rc)
816       return rc;
817
818     if( sig->sig_class == 0x00 ) {
819         if( c->mfx.md )
820           {
821             if (gcry_md_copy (&md, c->mfx.md ))
822               BUG ();
823           }
824         else /* detached signature */
825           {
826             /* signature_check() will enable the md*/
827             if (gcry_md_open (&md, 0, 0 ))
828               BUG ();
829           }
830     }
831     else if( sig->sig_class == 0x01 ) {
832         /* how do we know that we have to hash the (already hashed) text
833          * in canonical mode ??? (calculating both modes???) */
834         if( c->mfx.md ) {
835             if (gcry_md_copy (&md, c->mfx.md ))
836               BUG ();
837             if( c->mfx.md2 && gcry_md_copy (&md2, c->mfx.md2 ))
838               BUG ();
839         }
840         else { /* detached signature */
841             log_debug("Do we really need this here?");
842             /* signature_check() will enable the md*/
843             if (gcry_md_open (&md, 0, 0 ))
844               BUG ();
845             if (gcry_md_open (&md2, 0, 0 ))
846               BUG ();
847         }
848     }
849     else if( (sig->sig_class&~3) == 0x10
850              || sig->sig_class == 0x18
851              || sig->sig_class == 0x1f
852              || sig->sig_class == 0x20
853              || sig->sig_class == 0x28
854              || sig->sig_class == 0x30  ) { 
855         if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
856             || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
857             return check_key_signature( c->list, node, is_selfsig );
858         }
859         else if( sig->sig_class == 0x20 ) {
860             log_error (_("standalone revocation - "
861                          "use \"gpg --import\" to apply\n"));
862             return G10ERR_NOT_PROCESSED;
863         }
864         else {
865             log_error("invalid root packet for sigclass %02x\n",
866                                                         sig->sig_class);
867             return G10ERR_SIG_CLASS;
868         }
869     }
870     else
871         return G10ERR_SIG_CLASS;
872     rc = signature_check2( sig, md, NULL, is_expkey, is_revkey, NULL );
873     if( gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE && md2 )
874         rc = signature_check2( sig, md2, NULL, is_expkey, is_revkey, NULL );
875     gcry_md_close(md);
876     gcry_md_close(md2);
877
878     return rc;
879 }
880
881
882 static void
883 print_userid( PACKET *pkt )
884 {
885     if( !pkt )
886         BUG();
887     if( pkt->pkttype != PKT_USER_ID ) {
888         printf("ERROR: unexpected packet type %d", pkt->pkttype );
889         return;
890     }
891     if( opt.with_colons )
892       {
893         if(pkt->pkt.user_id->attrib_data)
894           printf("%u %lu",
895                  pkt->pkt.user_id->numattribs,
896                  pkt->pkt.user_id->attrib_len);
897         else
898           es_write_sanitized (es_stdout, pkt->pkt.user_id->name,
899                               pkt->pkt.user_id->len, ":", NULL);
900       }
901     else
902         print_utf8_buffer (es_stdout, pkt->pkt.user_id->name,
903                            pkt->pkt.user_id->len );
904 }
905
906
907 /****************
908  * List the certificate in a user friendly way
909  */
910
911 static void
912 list_node( CTX c, KBNODE node )
913 {
914     int any=0;
915     int mainkey;
916
917     if( !node )
918         ;
919     else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
920              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
921         PKT_public_key *pk = node->pkt->pkt.public_key;
922
923         if( opt.with_colons )
924           {
925             u32 keyid[2];
926             keyid_from_pk( pk, keyid );
927             if( mainkey )
928               c->trustletter = opt.fast_list_mode?
929                 0 : get_validity_info( pk, NULL );
930             printf("%s:", mainkey? "pub":"sub" );
931             if( c->trustletter )
932               putchar( c->trustletter );
933             printf(":%u:%d:%08lX%08lX:%s:%s::",
934                    nbits_from_pk( pk ),
935                    pk->pubkey_algo,
936                    (ulong)keyid[0],(ulong)keyid[1],
937                    colon_datestr_from_pk( pk ),
938                    colon_strtime (pk->expiredate) );
939             if( mainkey && !opt.fast_list_mode )
940               putchar( get_ownertrust_info (pk) );
941             putchar(':');
942             if( node->next && node->next->pkt->pkttype == PKT_RING_TRUST) {
943               putchar('\n'); any=1;
944               if( opt.fingerprint )
945                 print_fingerprint (pk, 0);
946               printf("rtv:1:%u:\n",
947                      node->next->pkt->pkt.ring_trust->trustval );
948             }
949           }
950         else
951           printf("%s  %4u%c/%s %s%s",
952                  mainkey? "pub":"sub", nbits_from_pk( pk ),
953                  pubkey_letter( pk->pubkey_algo ), keystr_from_pk( pk ),
954                  datestr_from_pk( pk ), mainkey?" ":"");
955
956         if( mainkey ) {
957             /* and now list all userids with their signatures */
958             for( node = node->next; node; node = node->next ) {
959                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
960                     if( !any ) {
961                         if( node->pkt->pkt.signature->sig_class == 0x20 )
962                             puts("[revoked]");
963                         else
964                             putchar('\n');
965                         any = 1;
966                     }
967                     list_node(c,  node );
968                 }
969                 else if( node->pkt->pkttype == PKT_USER_ID ) {
970                     if( any ) {
971                         if( opt.with_colons )
972                             printf("%s:::::::::",
973                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
974                         else
975                             printf( "uid%*s", 28, "" );
976                     }
977                     print_userid( node->pkt );
978                     if( opt.with_colons )
979                         putchar(':');
980                     putchar('\n');
981                     if( opt.fingerprint && !any )
982                         print_fingerprint ( pk, 0 );
983                     if( opt.with_colons
984                         && node->next
985                         && node->next->pkt->pkttype == PKT_RING_TRUST ) {
986                         printf("rtv:2:%u:\n",
987                                node->next->pkt->pkt.ring_trust?
988                                node->next->pkt->pkt.ring_trust->trustval : 0);
989                     }
990                     any=1;
991                 }
992                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
993                     if( !any ) {
994                         putchar('\n');
995                         any = 1;
996                     }
997                     list_node(c,  node );
998                 }
999             }
1000         }
1001         else
1002           {
1003             /* of subkey */
1004             if( pk->is_revoked )
1005               {
1006                 printf(" [");
1007                 printf(_("revoked: %s"),revokestr_from_pk(pk));
1008                 printf("]");
1009               }
1010             else if( pk->expiredate )
1011               {
1012                 printf(" [");
1013                 printf(_("expires: %s"),expirestr_from_pk(pk));
1014                 printf("]");
1015               }
1016           }
1017
1018         if( !any )
1019             putchar('\n');
1020         if( !mainkey && opt.fingerprint > 1 )
1021             print_fingerprint( pk, 0 );
1022     }
1023     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
1024              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1025
1026       log_debug ("FIXME: No way to print secret key packets here\n");
1027       /* fixme: We may use a fucntion to trun a secret key packet into
1028          a public key one and use that here.  */
1029         /* PKT_secret_key *sk = node->pkt->pkt.secret_key; */
1030
1031         /* if( opt.with_colons ) */
1032         /*   { */
1033         /*     u32 keyid[2]; */
1034         /*     keyid_from_sk( sk, keyid ); */
1035         /*     printf("%s::%u:%d:%08lX%08lX:%s:%s:::", */
1036         /*         mainkey? "sec":"ssb", */
1037         /*         nbits_from_sk( sk ), */
1038         /*         sk->pubkey_algo, */
1039         /*         (ulong)keyid[0],(ulong)keyid[1], */
1040         /*         colon_datestr_from_sk( sk ), */
1041         /*         colon_strtime (sk->expiredate) */
1042         /*         /\* fixme: add LID *\/ ); */
1043         /*   } */
1044         /* else */
1045         /*   printf("%s  %4u%c/%s %s ", mainkey? "sec":"ssb", */
1046         /*       nbits_from_sk( sk ), pubkey_letter( sk->pubkey_algo ), */
1047         /*       keystr_from_sk( sk ), datestr_from_sk( sk )); */
1048         /* if( mainkey ) { */
1049         /*     /\* and now list all userids with their signatures *\/ */
1050         /*     for( node = node->next; node; node = node->next ) { */
1051         /*      if( node->pkt->pkttype == PKT_SIGNATURE ) { */
1052         /*          if( !any ) { */
1053         /*              if( node->pkt->pkt.signature->sig_class == 0x20 ) */
1054         /*                  puts("[revoked]"); */
1055         /*              else */
1056         /*                  putchar('\n'); */
1057         /*              any = 1; */
1058         /*          } */
1059         /*          list_node(c,  node ); */
1060         /*      } */
1061         /*      else if( node->pkt->pkttype == PKT_USER_ID ) { */
1062         /*          if( any ) { */
1063         /*              if( opt.with_colons ) */
1064         /*                  printf("%s:::::::::", */
1065         /*                    node->pkt->pkt.user_id->attrib_data?"uat":"uid"); */
1066         /*              else */
1067         /*                  printf( "uid%*s", 28, "" ); */
1068         /*          } */
1069         /*          print_userid( node->pkt ); */
1070         /*          if( opt.with_colons ) */
1071         /*              putchar(':'); */
1072         /*          putchar('\n'); */
1073         /*          if( opt.fingerprint && !any ) */
1074         /*              print_fingerprint( NULL, sk, 0 ); */
1075         /*          any=1; */
1076         /*      } */
1077         /*      else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) { */
1078         /*          if( !any ) { */
1079         /*              putchar('\n'); */
1080         /*              any = 1; */
1081         /*          } */
1082         /*          list_node(c,  node ); */
1083         /*      } */
1084         /*     } */
1085         /* } */
1086         /* if( !any ) */
1087         /*     putchar('\n'); */
1088         /* if( !mainkey && opt.fingerprint > 1 ) */
1089         /*     print_fingerprint( NULL, sk, 0 ); */
1090     }
1091     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
1092         PKT_signature *sig = node->pkt->pkt.signature;
1093         int is_selfsig = 0;
1094         int rc2=0;
1095         size_t n;
1096         char *p;
1097         int sigrc = ' ';
1098
1099         if( !opt.verbose )
1100             return;
1101
1102         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
1103             fputs("rev", stdout);
1104         else
1105             fputs("sig", stdout);
1106         if( opt.check_sigs ) {
1107             fflush(stdout);
1108             rc2=do_check_sig( c, node, &is_selfsig, NULL, NULL );
1109             switch (gpg_err_code (rc2)) {
1110               case 0:                        sigrc = '!'; break;
1111               case GPG_ERR_BAD_SIGNATURE:    sigrc = '-'; break;
1112               case GPG_ERR_NO_PUBKEY: 
1113               case GPG_ERR_UNUSABLE_PUBKEY:  sigrc = '?'; break;
1114               default:                       sigrc = '%'; break;
1115             }
1116         }
1117         else {  /* check whether this is a self signature */
1118             u32 keyid[2];
1119
1120             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
1121                 || c->list->pkt->pkttype == PKT_SECRET_KEY ) {
1122                 if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
1123                     keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
1124                 else
1125                     keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
1126
1127                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
1128                     is_selfsig = 1;
1129             }
1130         }
1131         if( opt.with_colons ) {
1132             putchar(':');
1133             if( sigrc != ' ' )
1134                 putchar(sigrc);
1135             printf("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1136                    (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1137                    colon_datestr_from_sig(sig),
1138                    colon_expirestr_from_sig(sig));
1139
1140             if(sig->trust_depth || sig->trust_value)
1141               printf("%d %d",sig->trust_depth,sig->trust_value);
1142             printf(":");
1143
1144             if(sig->trust_regexp)
1145               es_write_sanitized (es_stdout,sig->trust_regexp,
1146                                   strlen(sig->trust_regexp), ":", NULL);
1147             printf(":");
1148         }
1149         else
1150           printf("%c       %s %s   ",
1151                  sigrc, keystr(sig->keyid), datestr_from_sig(sig));
1152         if( sigrc == '%' )
1153             printf("[%s] ", g10_errstr(rc2) );
1154         else if( sigrc == '?' )
1155             ;
1156         else if( is_selfsig ) {
1157             if( opt.with_colons )
1158                 putchar(':');
1159             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
1160             if( opt.with_colons )
1161                 putchar(':');
1162         }
1163         else if( !opt.fast_list_mode ) {
1164             p = get_user_id( sig->keyid, &n );
1165             es_write_sanitized (es_stdout, p, n,
1166                                 opt.with_colons?":":NULL, NULL );
1167             xfree(p);
1168         }
1169         if( opt.with_colons )
1170             printf(":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1171         putchar('\n');
1172     }
1173     else
1174         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
1175 }
1176
1177
1178
1179 int
1180 proc_packets( void *anchor, IOBUF a )
1181 {
1182     int rc;
1183     CTX c = xmalloc_clear( sizeof *c );
1184
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( 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->anchor = anchor;
1201     c->sigs_only = 1;
1202
1203     c->signed_data.data_fd = -1;
1204     c->signed_data.data_names = signedfiles;
1205     c->signed_data.used = !!signedfiles;
1206
1207     c->sigfilename = sigfilename;
1208     rc = do_proc_packets( c, a );
1209
1210     /* If we have not encountered any signature we print an error
1211        messages, send a NODATA status back and return an error code.
1212        Using log_error is required because verify_files does not check
1213        error codes for each file but we want to terminate the process
1214        with an error. */ 
1215     if (!rc && !c->any_sig_seen)
1216       {
1217         write_status_text (STATUS_NODATA, "4");
1218         log_error (_("no signature found\n"));
1219         rc = G10ERR_NO_DATA;
1220       }
1221
1222     /* Propagate the signature seen flag upward. Do this only on
1223        success so that we won't issue the nodata status several
1224        times. */
1225     if (!rc && c->anchor && c->any_sig_seen)
1226       c->anchor->any_sig_seen = 1;
1227
1228     xfree( c );
1229     return rc;
1230 }
1231
1232
1233 int
1234 proc_signature_packets_by_fd (void *anchor, IOBUF a, int signed_data_fd )
1235 {
1236   int rc;
1237   CTX c;
1238
1239   c = xtrycalloc (1, sizeof *c);
1240   if (!c)
1241     return gpg_error_from_syserror ();
1242
1243   c->anchor = anchor;
1244   c->sigs_only = 1;
1245
1246   c->signed_data.data_fd = signed_data_fd;
1247   c->signed_data.data_names = NULL;
1248   c->signed_data.used = (signed_data_fd != -1);
1249
1250   rc = do_proc_packets ( c, a );
1251
1252   /* If we have not encountered any signature we print an error
1253      messages, send a NODATA status back and return an error code.
1254      Using log_error is required because verify_files does not check
1255      error codes for each file but we want to terminate the process
1256      with an error. */ 
1257   if (!rc && !c->any_sig_seen)
1258     {
1259       write_status_text (STATUS_NODATA, "4");
1260       log_error (_("no signature found\n"));
1261       rc = gpg_error (GPG_ERR_NO_DATA);
1262     }
1263   
1264   /* Propagate the signature seen flag upward. Do this only on success
1265      so that we won't issue the nodata status several times. */
1266   if (!rc && c->anchor && c->any_sig_seen)
1267     c->anchor->any_sig_seen = 1;
1268   
1269   xfree ( c );
1270   return rc;
1271 }
1272
1273
1274 int
1275 proc_encryption_packets( void *anchor, IOBUF a )
1276 {
1277     CTX c = xmalloc_clear( sizeof *c );
1278     int rc;
1279
1280     c->anchor = anchor;
1281     c->encrypt_only = 1;
1282     rc = do_proc_packets( c, a );
1283     xfree( c );
1284     return rc;
1285 }
1286
1287
1288 int
1289 do_proc_packets( CTX c, IOBUF a )
1290 {
1291     PACKET *pkt = xmalloc( sizeof *pkt );
1292     int rc=0;
1293     int any_data=0;
1294     int newpkt;
1295
1296     c->iobuf = a;
1297     init_packet(pkt);
1298     while( (rc=parse_packet(a, pkt)) != -1 ) {
1299         any_data = 1;
1300         if( rc ) {
1301             free_packet(pkt);
1302             /* stop processing when an invalid packet has been encountered
1303              * but don't do so when we are doing a --list-packets. */
1304             if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
1305                 && opt.list_packets != 2 )
1306                 break;
1307             continue;
1308         }
1309         newpkt = -1;
1310         if( opt.list_packets ) {
1311             switch( pkt->pkttype ) {
1312               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1313               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1314               case PKT_ENCRYPTED:
1315               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1316               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1317               default: newpkt = 0; break;
1318             }
1319         }
1320         else if( c->sigs_only ) {
1321             switch( pkt->pkttype ) {
1322               case PKT_PUBLIC_KEY:
1323               case PKT_SECRET_KEY:
1324               case PKT_USER_ID:
1325               case PKT_SYMKEY_ENC:
1326               case PKT_PUBKEY_ENC:
1327               case PKT_ENCRYPTED:
1328               case PKT_ENCRYPTED_MDC:
1329                 write_status_text( STATUS_UNEXPECTED, "0" );
1330                 rc = G10ERR_UNEXPECTED;
1331                 goto leave;
1332               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1333               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1334               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1335               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1336               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1337               default: newpkt = 0; break;
1338             }
1339         }
1340         else if( c->encrypt_only ) {
1341             switch( pkt->pkttype ) {
1342               case PKT_PUBLIC_KEY:
1343               case PKT_SECRET_KEY:
1344               case PKT_USER_ID:
1345                 write_status_text( STATUS_UNEXPECTED, "0" );
1346                 rc = G10ERR_UNEXPECTED;
1347                 goto leave;
1348               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1349               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1350               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1351               case PKT_ENCRYPTED:
1352               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1353               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1354               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1355               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1356               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1357               default: newpkt = 0; break;
1358             }
1359         }
1360         else {
1361             switch( pkt->pkttype ) {
1362               case PKT_PUBLIC_KEY:
1363               case PKT_SECRET_KEY:
1364                 release_list( c );
1365                 c->list = new_kbnode( pkt );
1366                 newpkt = 1;
1367                 break;
1368               case PKT_PUBLIC_SUBKEY:
1369               case PKT_SECRET_SUBKEY:
1370                 newpkt = add_subkey( c, pkt );
1371                 break;
1372               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
1373               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1374               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1375               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1376               case PKT_ENCRYPTED:
1377               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1378               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1379               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1380               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1381               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1382               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
1383               default: newpkt = 0; break;
1384             }
1385         }
1386         /* This is a very ugly construct and frankly, I don't remember why
1387          * I used it.  Adding the MDC check here is a hack.
1388          * The right solution is to initiate another context for encrypted
1389          * packet and not to reuse the current one ...  It works right
1390          * when there is a compression packet inbetween which adds just
1391          * an extra layer.
1392          * Hmmm: Rewrite this whole module here?? 
1393          */
1394         if( pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC )
1395             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
1396
1397         if( newpkt == -1 )
1398             ;
1399         else if( newpkt ) {
1400             pkt = xmalloc( sizeof *pkt );
1401             init_packet(pkt);
1402         }
1403         else
1404             free_packet(pkt);
1405     }
1406     if( rc == G10ERR_INVALID_PACKET )
1407         write_status_text( STATUS_NODATA, "3" );
1408     if( any_data )
1409         rc = 0;
1410     else if( rc == -1 )
1411         write_status_text( STATUS_NODATA, "2" );
1412
1413
1414   leave:
1415     release_list( c );
1416     xfree(c->dek);
1417     free_packet( pkt );
1418     xfree( pkt );
1419     free_md_filter_context( &c->mfx );
1420     return rc;
1421 }
1422
1423
1424 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1425    of the notation data. */
1426 static pka_info_t *
1427 get_pka_address (PKT_signature *sig)
1428 {
1429   pka_info_t *pka = NULL;
1430   struct notation *nd,*notation;
1431
1432   notation=sig_to_notation(sig);
1433
1434   for(nd=notation;nd;nd=nd->next)
1435     {
1436       if(strcmp(nd->name,"pka-address@gnupg.org")!=0)
1437         continue; /* Not the notation we want. */
1438
1439       /* For now we only use the first valid PKA notation. In future
1440          we might want to keep additional PKA notations in a linked
1441          list. */
1442       if (is_valid_mailbox (nd->value))
1443         {
1444           pka = xmalloc (sizeof *pka + strlen(nd->value));
1445           pka->valid = 0;
1446           pka->checked = 0;
1447           pka->uri = NULL;
1448           strcpy (pka->email, nd->value);
1449           break;
1450         }
1451     }
1452
1453   free_notation(notation);
1454
1455   return pka;
1456 }
1457
1458
1459 /* Return the URI from a DNS PKA record.  If this record has already
1460    be retrieved for the signature we merely return it; if not we go
1461    out and try to get that DNS record. */
1462 static const char *
1463 pka_uri_from_sig (PKT_signature *sig)
1464 {
1465   if (!sig->flags.pka_tried)
1466     {
1467       assert (!sig->pka_info);
1468       sig->flags.pka_tried = 1;
1469       sig->pka_info = get_pka_address (sig);
1470       if (sig->pka_info)
1471         {
1472           char *uri;
1473
1474           uri = get_pka_info (sig->pka_info->email, sig->pka_info->fpr);
1475           if (uri)
1476             {
1477               sig->pka_info->valid = 1;
1478               if (!*uri)
1479                 xfree (uri);
1480               else
1481                 sig->pka_info->uri = uri;
1482             }
1483         }
1484     }
1485   return sig->pka_info? sig->pka_info->uri : NULL;
1486 }
1487
1488
1489 static int
1490 check_sig_and_print( CTX c, KBNODE node )
1491 {
1492   PKT_signature *sig = node->pkt->pkt.signature;
1493   const char *astr;
1494   int rc, is_expkey=0, is_revkey=0;
1495
1496   if (opt.skip_verify)
1497     {
1498       log_info(_("signature verification suppressed\n"));
1499       return 0;
1500     }
1501
1502   /* Check that the message composition is valid.
1503
1504      Per RFC-2440bis (-15) allowed:
1505
1506      S{1,n}           -- detached signature.
1507      S{1,n} P         -- old style PGP2 signature
1508      O{1,n} P S{1,n}  -- standard OpenPGP signature.
1509      C P S{1,n}       -- cleartext signature.
1510
1511         
1512           O = One-Pass Signature packet.
1513           S = Signature packet.
1514           P = OpenPGP Message packet (Encrypted | Compressed | Literal)
1515                  (Note that the current rfc2440bis draft also allows
1516                   for a signed message but that does not work as it
1517                   introduces ambiguities.)
1518               We keep track of these packages using the marker packet
1519               CTRLPKT_PLAINTEXT_MARK.
1520           C = Marker packet for cleartext signatures.
1521
1522      We reject all other messages.
1523      
1524      Actually we are calling this too often, i.e. for verification of
1525      each message but better have some duplicate work than to silently
1526      introduce a bug here.
1527   */
1528   {
1529     KBNODE n;
1530     int n_onepass, n_sig;
1531
1532 /*     log_debug ("checking signature packet composition\n"); */
1533 /*     dump_kbnode (c->list); */
1534
1535     n = c->list;
1536     assert (n);
1537     if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1538       {
1539         /* This is either "S{1,n}" case (detached signature) or
1540            "S{1,n} P" (old style PGP2 signature). */
1541         for (n = n->next; n; n = n->next)
1542           if (n->pkt->pkttype != PKT_SIGNATURE)
1543             break;
1544         if (!n)
1545           ; /* Okay, this is a detached signature.  */
1546         else if (n->pkt->pkttype == PKT_GPG_CONTROL
1547                  && (n->pkt->pkt.gpg_control->control
1548                      == CTRLPKT_PLAINTEXT_MARK) )
1549           {
1550             if (n->next)
1551               goto ambiguous;  /* We only allow one P packet. */
1552           }
1553         else
1554           goto ambiguous;
1555       }
1556     else if (n->pkt->pkttype == PKT_ONEPASS_SIG) 
1557       {
1558         /* This is the "O{1,n} P S{1,n}" case (standard signature). */
1559         for (n_onepass=1, n = n->next;
1560              n && n->pkt->pkttype == PKT_ONEPASS_SIG; n = n->next)
1561           n_onepass++;
1562         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1563                     && (n->pkt->pkt.gpg_control->control
1564                         == CTRLPKT_PLAINTEXT_MARK)))
1565           goto ambiguous;
1566         for (n_sig=0, n = n->next;
1567              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1568           n_sig++;
1569         if (!n_sig)
1570           goto ambiguous;
1571
1572         /* If we wanted to disallow multiple sig verification, we'd do
1573            something like this:
1574
1575            if (n && !opt.allow_multisig_verification)
1576              goto ambiguous;
1577
1578            However, now that we have --allow-multiple-messages, this
1579            can stay allowable as we can't get here unless multiple
1580            messages (i.e. multiple literals) are allowed. */
1581
1582         if (n_onepass != n_sig)
1583           {
1584             log_info ("number of one-pass packets does not match "
1585                       "number of signature packets\n");
1586             goto ambiguous;
1587           }
1588       }
1589     else if (n->pkt->pkttype == PKT_GPG_CONTROL
1590              && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
1591       {
1592         /* This is the "C P S{1,n}" case (clear text signature). */
1593         n = n->next;
1594         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1595                     && (n->pkt->pkt.gpg_control->control
1596                         == CTRLPKT_PLAINTEXT_MARK)))
1597           goto ambiguous;
1598         for (n_sig=0, n = n->next;
1599              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1600           n_sig++;
1601         if (n || !n_sig)
1602           goto ambiguous;
1603       }
1604     else 
1605       {
1606       ambiguous:
1607         log_error(_("can't handle this ambiguous signature data\n"));
1608         return 0;
1609       }
1610
1611   }
1612
1613   /* (Indendation below not yet changed to GNU style.) */
1614
1615     astr = gcry_pk_algo_name ( sig->pubkey_algo );
1616     if(keystrlen()>8)
1617       {
1618         log_info(_("Signature made %s\n"),asctimestamp(sig->timestamp));
1619         log_info(_("               using %s key %s\n"),
1620                  astr? astr: "?",keystr(sig->keyid));
1621       }
1622     else
1623       log_info(_("Signature made %s using %s key ID %s\n"),
1624                asctimestamp(sig->timestamp), astr? astr: "?",
1625                keystr(sig->keyid));
1626
1627     rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1628
1629     /* If the key isn't found, check for a preferred keyserver */
1630
1631     if(rc==G10ERR_NO_PUBKEY && sig->flags.pref_ks)
1632       {
1633         const byte *p;
1634         int seq=0;
1635         size_t n;
1636
1637         while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1638           {
1639             /* According to my favorite copy editor, in English
1640                grammar, you say "at" if the key is located on a web
1641                page, but "from" if it is located on a keyserver.  I'm
1642                not going to even try to make two strings here :) */
1643             log_info(_("Key available at: ") );
1644             print_utf8_buffer (log_get_stream(), p, n);
1645             log_printf ("\n");
1646
1647             if(opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1648                && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1649               {
1650                 struct keyserver_spec *spec;
1651
1652                 spec=parse_preferred_keyserver(sig);
1653                 if(spec)
1654                   {
1655                     int res;
1656
1657                     glo_ctrl.in_auto_key_retrieve++;
1658                     res=keyserver_import_keyid(sig->keyid,spec);
1659                     glo_ctrl.in_auto_key_retrieve--;
1660                     if(!res)
1661                       rc=do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1662                     free_keyserver_spec(spec);
1663
1664                     if(!rc)
1665                       break;
1666                   }
1667               }
1668           }
1669       }
1670
1671     /* If the preferred keyserver thing above didn't work, our second
1672        try is to use the URI from a DNS PKA record. */
1673     if ( rc == G10ERR_NO_PUBKEY 
1674          && opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1675          && opt.keyserver_options.options&KEYSERVER_HONOR_PKA_RECORD)
1676       {
1677         const char *uri = pka_uri_from_sig (sig);
1678         
1679         if (uri)
1680           {
1681             /* FIXME: We might want to locate the key using the
1682                fingerprint instead of the keyid. */
1683             int res;
1684             struct keyserver_spec *spec;
1685             
1686             spec = parse_keyserver_uri (uri, 1, NULL, 0);
1687             if (spec)
1688               {
1689                 glo_ctrl.in_auto_key_retrieve++;
1690                 res = keyserver_import_keyid (sig->keyid, spec);
1691                 glo_ctrl.in_auto_key_retrieve--;
1692                 free_keyserver_spec (spec);
1693                 if (!res)
1694                   rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1695               }
1696           }
1697       }
1698
1699     /* If the preferred keyserver thing above didn't work and we got
1700        no information from the DNS PKA, this is a third try. */
1701
1702     if( rc == G10ERR_NO_PUBKEY && opt.keyserver
1703         && opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
1704       {
1705         int res;
1706
1707         glo_ctrl.in_auto_key_retrieve++;
1708         res=keyserver_import_keyid ( sig->keyid, opt.keyserver );
1709         glo_ctrl.in_auto_key_retrieve--;
1710         if(!res)
1711           rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1712       }
1713
1714     if( !rc || gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE ) {
1715         KBNODE un, keyblock;
1716         int count=0, statno;
1717         char keyid_str[50];
1718         PKT_public_key *pk=NULL;
1719
1720         if(rc)
1721           statno=STATUS_BADSIG;
1722         else if(sig->flags.expired)
1723           statno=STATUS_EXPSIG;
1724         else if(is_expkey)
1725           statno=STATUS_EXPKEYSIG;
1726         else if(is_revkey)
1727           statno=STATUS_REVKEYSIG;
1728         else
1729           statno=STATUS_GOODSIG;
1730
1731         keyblock = get_pubkeyblock( sig->keyid );
1732
1733         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1734                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1735
1736         /* find and print the primary user ID */
1737         for( un=keyblock; un; un = un->next ) {
1738             char *p;
1739             int valid;
1740             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1741               {
1742                 pk=un->pkt->pkt.public_key;
1743                 continue;
1744               }
1745             if( un->pkt->pkttype != PKT_USER_ID )
1746                 continue;
1747             if ( !un->pkt->pkt.user_id->created )
1748                 continue;
1749             if ( un->pkt->pkt.user_id->is_revoked )
1750                 continue;
1751             if ( un->pkt->pkt.user_id->is_expired )
1752                 continue;
1753             if ( !un->pkt->pkt.user_id->is_primary )
1754                 continue;
1755             /* We want the textual primary user ID here */
1756             if ( un->pkt->pkt.user_id->attrib_data )
1757                 continue;
1758
1759             assert(pk);
1760
1761             /* Get it before we print anything to avoid interrupting
1762                the output with the "please do a --check-trustdb"
1763                line. */
1764             valid=get_validity(pk,un->pkt->pkt.user_id);
1765
1766             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1767             write_status_text_and_buffer (statno, keyid_str,
1768                                           un->pkt->pkt.user_id->name,
1769                                           un->pkt->pkt.user_id->len, 
1770                                           -1 );
1771
1772             p=utf8_to_native(un->pkt->pkt.user_id->name,
1773                              un->pkt->pkt.user_id->len,0);
1774
1775             if(rc)
1776               log_info(_("BAD signature from \"%s\""),p);
1777             else if(sig->flags.expired)
1778               log_info(_("Expired signature from \"%s\""),p);
1779             else
1780               log_info(_("Good signature from \"%s\""),p);
1781
1782             xfree(p);
1783
1784             if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1785               log_printf (" [%s]\n",trust_value_to_string(valid));
1786             else
1787               log_printf ("\n");
1788             count++;
1789         }
1790         if( !count ) {  /* just in case that we have no valid textual
1791                            userid */
1792             char *p;
1793
1794             /* Try for an invalid textual userid */
1795             for( un=keyblock; un; un = un->next ) {
1796                 if( un->pkt->pkttype == PKT_USER_ID &&
1797                     !un->pkt->pkt.user_id->attrib_data )
1798                     break;
1799             }
1800
1801             /* Try for any userid at all */
1802             if(!un) {
1803                 for( un=keyblock; un; un = un->next ) {
1804                     if( un->pkt->pkttype == PKT_USER_ID )
1805                         break;
1806                 }
1807             }
1808
1809             if (opt.trust_model==TM_ALWAYS || !un)
1810                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1811
1812             write_status_text_and_buffer (statno, keyid_str,
1813                                           un? un->pkt->pkt.user_id->name:"[?]",
1814                                           un? un->pkt->pkt.user_id->len:3, 
1815                                           -1 );
1816
1817             if(un)
1818               p=utf8_to_native(un->pkt->pkt.user_id->name,
1819                                un->pkt->pkt.user_id->len,0);
1820             else
1821               p=xstrdup("[?]");
1822
1823             if(rc)
1824               log_info(_("BAD signature from \"%s\""),p);
1825             else if(sig->flags.expired)
1826               log_info(_("Expired signature from \"%s\""),p);
1827             else
1828               log_info(_("Good signature from \"%s\""),p);
1829             if (opt.trust_model!=TM_ALWAYS && un)
1830               log_printf (" %s",_("[uncertain]") );
1831             log_printf ("\n");
1832         }
1833
1834         /* If we have a good signature and already printed 
1835          * the primary user ID, print all the other user IDs */
1836         if ( count && !rc
1837              && !(opt.verify_options&VERIFY_SHOW_PRIMARY_UID_ONLY)) {
1838             char *p;
1839             for( un=keyblock; un; un = un->next ) {
1840                 if( un->pkt->pkttype != PKT_USER_ID )
1841                     continue;
1842                 if((un->pkt->pkt.user_id->is_revoked
1843                     || un->pkt->pkt.user_id->is_expired)
1844                    && !(opt.verify_options&VERIFY_SHOW_UNUSABLE_UIDS))
1845                   continue;
1846                 /* Only skip textual primaries */
1847                 if ( un->pkt->pkt.user_id->is_primary &&
1848                      !un->pkt->pkt.user_id->attrib_data )
1849                     continue;
1850
1851                 if(un->pkt->pkt.user_id->attrib_data)
1852                   {
1853                     dump_attribs (un->pkt->pkt.user_id, pk);
1854
1855                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1856                       show_photos(un->pkt->pkt.user_id->attribs,
1857                                   un->pkt->pkt.user_id->numattribs,
1858                                   pk ,un->pkt->pkt.user_id);
1859                   }
1860
1861                 p=utf8_to_native(un->pkt->pkt.user_id->name,
1862                                  un->pkt->pkt.user_id->len,0);
1863                 log_info(_("                aka \"%s\""),p);
1864                 xfree(p);
1865
1866                 if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1867                   {
1868                     const char *valid;
1869                     if(un->pkt->pkt.user_id->is_revoked)
1870                       valid=_("revoked");
1871                     else if(un->pkt->pkt.user_id->is_expired)
1872                       valid=_("expired");
1873                     else
1874                       valid=trust_value_to_string(get_validity(pk,
1875                                                                un->pkt->
1876                                                                pkt.user_id));
1877                     log_printf (" [%s]\n",valid);
1878                   }
1879                 else
1880                   log_printf ("\n");
1881             }
1882         }
1883         release_kbnode( keyblock );
1884
1885         if( !rc )
1886           {
1887             if(opt.verify_options&VERIFY_SHOW_POLICY_URLS)
1888               show_policy_url(sig,0,1);
1889             else
1890               show_policy_url(sig,0,2);
1891
1892             if(opt.verify_options&VERIFY_SHOW_KEYSERVER_URLS)
1893               show_keyserver_url(sig,0,1);
1894             else
1895               show_keyserver_url(sig,0,2);
1896
1897             if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
1898               show_notation(sig,0,1,
1899                         ((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)+
1900                         ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0));
1901             else
1902               show_notation(sig,0,2,0);
1903           }
1904
1905         if( !rc && is_status_enabled() ) {
1906             /* print a status response with the fingerprint */
1907             PKT_public_key *vpk = xmalloc_clear( sizeof *vpk );
1908
1909             if( !get_pubkey( vpk, sig->keyid ) ) {
1910                 byte array[MAX_FINGERPRINT_LEN], *p;
1911                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1912                 size_t i, n;
1913
1914                 bufp = buf;
1915                 fingerprint_from_pk( vpk, array, &n );
1916                 p = array;
1917                 for(i=0; i < n ; i++, p++, bufp += 2)
1918                     sprintf(bufp, "%02X", *p );
1919                 /* TODO: Replace the reserved '0' in the field below
1920                    with bits for status flags (policy url, notation,
1921                    etc.).  Remember to make the buffer larger to
1922                    match! */
1923                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1924                         strtimestamp( sig->timestamp ),
1925                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1926                         sig->version,sig->pubkey_algo,sig->digest_algo,
1927                         sig->sig_class);
1928                 bufp = bufp + strlen (bufp);
1929                 if (!vpk->is_primary) {
1930                    u32 akid[2];
1931  
1932                    akid[0] = vpk->main_keyid[0];
1933                    akid[1] = vpk->main_keyid[1];
1934                    free_public_key (vpk);
1935                    vpk = xmalloc_clear( sizeof *vpk );
1936                    if (get_pubkey (vpk, akid)) {
1937                      /* impossible error, we simply return a zeroed out fpr */
1938                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1939                      memset (array, 0, n);
1940                    }
1941                    else
1942                      fingerprint_from_pk( vpk, array, &n );
1943                 }
1944                 p = array;
1945                 for(i=0; i < n ; i++, p++, bufp += 2)
1946                     sprintf(bufp, "%02X", *p );
1947                 write_status_text( STATUS_VALIDSIG, buf );
1948             }
1949             free_public_key( vpk );
1950         }
1951
1952         if (!rc)
1953           {
1954             if(opt.verify_options&VERIFY_PKA_LOOKUPS)
1955               pka_uri_from_sig (sig); /* Make sure PKA info is available. */
1956             rc = check_signatures_trust( sig );
1957           }
1958
1959         if(sig->flags.expired)
1960           {
1961             log_info(_("Signature expired %s\n"),
1962                      asctimestamp(sig->expiredate));
1963             rc=G10ERR_GENERAL; /* need a better error here? */
1964           }
1965         else if(sig->expiredate)
1966           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
1967
1968         if(opt.verbose)
1969           log_info(_("%s signature, digest algorithm %s\n"),
1970                    sig->sig_class==0x00?_("binary"):
1971                    sig->sig_class==0x01?_("textmode"):_("unknown"),
1972                    gcry_md_algo_name (sig->digest_algo));
1973
1974         if( rc )
1975             g10_errors_seen = 1;
1976         if( opt.batch && rc )
1977             g10_exit(1);
1978     }
1979     else {
1980         char buf[50];
1981         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1982                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1983                      sig->pubkey_algo, sig->digest_algo,
1984                      sig->sig_class, (ulong)sig->timestamp, rc );
1985         write_status_text( STATUS_ERRSIG, buf );
1986         if( rc == G10ERR_NO_PUBKEY ) {
1987             buf[16] = 0;
1988             write_status_text( STATUS_NO_PUBKEY, buf );
1989         }
1990         if( rc != G10ERR_NOT_PROCESSED )
1991             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1992     }
1993     return rc;
1994 }
1995
1996
1997 /****************
1998  * Process the tree which starts at node
1999  */
2000 static void
2001 proc_tree( CTX c, KBNODE node )
2002 {
2003     KBNODE n1;
2004     int rc;
2005
2006     if( opt.list_packets || opt.list_only )
2007         return;
2008
2009     /* we must skip our special plaintext marker packets here becuase
2010        they may be the root packet.  These packets are only used in
2011        addionla checks and skipping them here doesn't matter */
2012     while ( node
2013             && node->pkt->pkttype == PKT_GPG_CONTROL
2014             && node->pkt->pkt.gpg_control->control
2015                          == CTRLPKT_PLAINTEXT_MARK ) {
2016         node = node->next;
2017     }
2018     if (!node)
2019         return;
2020
2021     c->trustletter = ' ';
2022     if( node->pkt->pkttype == PKT_PUBLIC_KEY
2023         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2024         merge_keys_and_selfsig( node );
2025         list_node( c, node );
2026     }
2027     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
2028         merge_keys_and_selfsig( node );
2029         list_node( c, node );
2030     }
2031     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
2032         /* check all signatures */
2033         if( !c->have_data ) {
2034             int use_textmode = 0;
2035
2036             free_md_filter_context( &c->mfx );
2037             /* prepare to create all requested message digests */
2038             if (gcry_md_open (&c->mfx.md, 0, 0))
2039               BUG ();
2040
2041             /* fixme: why looking for the signature packet and not the
2042                one-pass packet? */
2043             for ( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
2044               {
2045                 gcry_md_enable (c->mfx.md,
2046                                 n1->pkt->pkt.signature->digest_algo);
2047               }
2048
2049             if (n1 && n1->pkt->pkt.onepass_sig->sig_class == 0x01)
2050                 use_textmode = 1;
2051
2052             /* Ask for file and hash it. */
2053             if( c->sigs_only ) {
2054                 if (c->signed_data.used && c->signed_data.data_fd != -1)
2055                     rc = hash_datafile_by_fd (c->mfx.md, NULL,
2056                                               c->signed_data.data_fd,
2057                                               use_textmode);
2058                 else
2059                     rc = hash_datafiles (c->mfx.md, NULL,
2060                                          c->signed_data.data_names,
2061                                          c->sigfilename,
2062                                          use_textmode );
2063             }
2064             else {
2065                 rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2066                                                 iobuf_get_real_fname(c->iobuf),
2067                                                 use_textmode );
2068             }
2069             if( rc ) {
2070                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
2071                 return;
2072             }
2073         }
2074         else if ( c->signed_data.used ) {
2075             log_error (_("not a detached signature\n") );
2076             return;
2077         }
2078
2079         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
2080             check_sig_and_print( c, n1 );
2081     }
2082     else if( node->pkt->pkttype == PKT_GPG_CONTROL
2083              && node->pkt->pkt.gpg_control->control
2084                 == CTRLPKT_CLEARSIGN_START ) {
2085         /* clear text signed message */
2086         if( !c->have_data ) {
2087             log_error("cleartext signature without data\n" );
2088             return;
2089         }
2090         else if ( c->signed_data.used ) {
2091             log_error (_("not a detached signature\n") );
2092             return;
2093         }
2094         
2095         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
2096             check_sig_and_print( c, n1 );
2097     }
2098     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
2099         PKT_signature *sig = node->pkt->pkt.signature;
2100         int multiple_ok=1;
2101
2102         n1=find_next_kbnode(node, PKT_SIGNATURE);
2103         if(n1)
2104           {
2105             byte class=sig->sig_class;
2106             byte hash=sig->digest_algo;
2107
2108             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2109               {
2110                 /* We can't currently handle multiple signatures of
2111                    different classes or digests (we'd pretty much have
2112                    to run a different hash context for each), but if
2113                    they are all the same, make an exception. */
2114                 if(n1->pkt->pkt.signature->sig_class!=class
2115                    || n1->pkt->pkt.signature->digest_algo!=hash)
2116                   {
2117                     multiple_ok=0;
2118                     log_info(_("WARNING: multiple signatures detected.  "
2119                                "Only the first will be checked.\n"));
2120                     break;
2121                   }
2122               }
2123           }
2124
2125         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
2126             log_info(_("standalone signature of class 0x%02x\n"),
2127                                                     sig->sig_class);
2128         else if( !c->have_data ) {
2129             /* detached signature */
2130             free_md_filter_context( &c->mfx );
2131             if (gcry_md_open (&c->mfx.md, sig->digest_algo, 0))
2132               BUG ();
2133
2134             if( !opt.pgp2_workarounds )
2135                 ;
2136             else if( sig->digest_algo == DIGEST_ALGO_MD5
2137                      && is_RSA( sig->pubkey_algo ) ) {
2138                 /* enable a workaround for a pgp2 bug */
2139                 if (gcry_md_open (&c->mfx.md2, DIGEST_ALGO_MD5, 0))
2140                   BUG ();
2141             }
2142             else if( sig->digest_algo == DIGEST_ALGO_SHA1
2143                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
2144                      && sig->sig_class == 0x01 ) {
2145                 /* enable the workaround also for pgp5 when the detached
2146                  * signature has been created in textmode */
2147               if (gcry_md_open (&c->mfx.md2, sig->digest_algo, 0 ))
2148                 BUG ();
2149             }
2150 #if 0 /* workaround disabled */
2151             /* Here we have another hack to work around a pgp 2 bug
2152              * It works by not using the textmode for detached signatures;
2153              * this will let the first signature check (on md) fail
2154              * but the second one (on md2) which adds an extra CR should
2155              * then produce the "correct" hash.  This is very, very ugly
2156              * hack but it may help in some cases (and break others)
2157              */
2158                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
2159 #endif
2160             if ( DBG_HASHING ) {
2161                 gcry_md_start_debug( c->mfx.md, "verify" );
2162                 if ( c->mfx.md2  )
2163                     gcry_md_start_debug( c->mfx.md2, "verify2" );
2164             }
2165             if( c->sigs_only ) {
2166                 if (c->signed_data.used && c->signed_data.data_fd != -1)
2167                     rc = hash_datafile_by_fd (c->mfx.md, c->mfx.md2,
2168                                               c->signed_data.data_fd, 
2169                                               (sig->sig_class == 0x01));
2170                 else
2171                     rc = hash_datafiles (c->mfx.md, c->mfx.md2,
2172                                          c->signed_data.data_names,
2173                                          c->sigfilename,
2174                                          (sig->sig_class == 0x01));
2175             }
2176             else {
2177                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
2178                                                 iobuf_get_real_fname(c->iobuf),
2179                                                 (sig->sig_class == 0x01) );
2180             }
2181             if( rc ) {
2182                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
2183                 return;
2184             }
2185         }
2186         else if ( c->signed_data.used ) {
2187             log_error (_("not a detached signature\n") );
2188             return;
2189         }
2190         else if (!opt.quiet)
2191             log_info(_("old style (PGP 2.x) signature\n"));
2192
2193         if(multiple_ok)
2194           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
2195             check_sig_and_print( c, n1 );
2196         else
2197           check_sig_and_print( c, node );
2198     }
2199     else {
2200         dump_kbnode (c->list);
2201         log_error(_("invalid root packet detected in proc_tree()\n"));
2202         dump_kbnode (node);
2203     }
2204 }