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