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