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