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