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