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