gpg: Change --show-session-key to print the session key earlier.
[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 "util.h"
31 #include "packet.h"
32 #include "iobuf.h"
33 #include "options.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   ctrl_t ctrl;
66   struct mainproc_context *anchor;  /* May be useful in the future. */
67   PKT_public_key *last_pubkey;
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 fields
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   memcpy(dek->key, seskey + 1, dek->keylen);
265
266   /*log_hexdump( "thekey", dek->key, dek->keylen );*/
267
268   return 0;
269 }
270
271 static void
272 proc_symkey_enc( CTX c, PACKET *pkt )
273 {
274     PKT_symkey_enc *enc;
275
276     enc = pkt->pkt.symkey_enc;
277     if (!enc)
278         log_error ("invalid symkey encrypted packet\n");
279     else if(!c->dek)
280       {
281         int algo = enc->cipher_algo;
282         const char *s = openpgp_cipher_algo_name (algo);
283
284         if (!openpgp_cipher_test_algo (algo))
285           {
286             if(!opt.quiet)
287               {
288                 if(enc->seskeylen)
289                   log_info(_("%s encrypted session key\n"), s );
290                 else
291                   log_info(_("%s encrypted data\n"), s );
292               }
293           }
294         else
295           log_error(_("encrypted with unknown algorithm %d\n"), algo );
296
297         if(openpgp_md_test_algo (enc->s2k.hash_algo))
298           {
299             log_error(_("passphrase generated with unknown digest"
300                         " algorithm %d\n"),enc->s2k.hash_algo);
301             s=NULL;
302           }
303
304         c->last_was_session_key = 2;
305         if(!s || opt.list_only)
306           goto leave;
307
308         if(opt.override_session_key)
309           {
310             c->dek = xmalloc_clear( sizeof *c->dek );
311             if(get_override_session_key(c->dek, opt.override_session_key))
312               {
313                 xfree(c->dek);
314                 c->dek = NULL;
315               }
316           }
317         else
318           {
319             c->dek = passphrase_to_dek (NULL, 0, algo, &enc->s2k, 3,
320                                         NULL, NULL);
321             if(c->dek)
322               {
323                 c->dek->symmetric=1;
324
325                 /* FIXME: This doesn't work perfectly if a symmetric
326                    key comes before a public key in the message - if
327                    the user doesn't know the passphrase, then there is
328                    a chance that the "decrypted" algorithm will happen
329                    to be a valid one, which will make the returned dek
330                    appear valid, so we won't try any public keys that
331                    come later. */
332                 if(enc->seskeylen)
333                   {
334                     if(symkey_decrypt_seskey(c->dek, enc->seskey,
335                                              enc->seskeylen))
336                       {
337                         xfree(c->dek);
338                         c->dek=NULL;
339                       }
340                   }
341                 else
342                   c->dek->algo_info_printed = 1;
343               }
344           }
345       }
346
347  leave:
348     c->symkeys++;
349     free_packet(pkt);
350 }
351
352 static void
353 proc_pubkey_enc( CTX c, PACKET *pkt )
354 {
355     PKT_pubkey_enc *enc;
356     int result = 0;
357
358     /* check whether the secret key is available and store in this case */
359     c->last_was_session_key = 1;
360     enc = pkt->pkt.pubkey_enc;
361     /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
362     /* Hmmm: why do I have this algo check here - anyway there is
363      * function to check it. */
364     if( opt.verbose )
365         log_info(_("public key is %s\n"), keystr(enc->keyid) );
366
367     if( is_status_enabled() ) {
368         char buf[50];
369         /* FIXME: For ECC support we need to map the OpenPGP algo
370            number to the Libgcrypt definef one.  This is due a
371            chicken-egg problem: We need to have code in libgcrypt for
372            a new algorithm so to implement a proposed new algorithm
373            before the IANA will finally assign an OpenPGP
374            indentifier.  */
375         snprintf (buf, sizeof 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              || enc->pubkey_algo == PUBKEY_ALGO_ECDSA
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 any=0;
925     int mainkey;
926
927     if( !node )
928         ;
929     else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
930              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
931         PKT_public_key *pk = node->pkt->pkt.public_key;
932
933         if( opt.with_colons )
934           {
935             u32 keyid[2];
936             keyid_from_pk( pk, keyid );
937             if( mainkey )
938               c->trustletter = opt.fast_list_mode?
939                 0 : get_validity_info( pk, NULL );
940             printf("%s:", mainkey? "pub":"sub" );
941             if( c->trustletter )
942               putchar( c->trustletter );
943             printf(":%u:%d:%08lX%08lX:%s:%s::",
944                    nbits_from_pk( pk ),
945                    pk->pubkey_algo,
946                    (ulong)keyid[0],(ulong)keyid[1],
947                    colon_datestr_from_pk( pk ),
948                    colon_strtime (pk->expiredate) );
949             if( mainkey && !opt.fast_list_mode )
950               putchar( get_ownertrust_info (pk) );
951             putchar(':');
952             if( node->next && node->next->pkt->pkttype == PKT_RING_TRUST) {
953               putchar('\n'); any=1;
954               if( opt.fingerprint )
955                 print_fingerprint (pk, 0);
956               printf("rtv:1:%u:\n",
957                      node->next->pkt->pkt.ring_trust->trustval );
958             }
959           }
960         else
961           printf("%s  %4u%c/%s %s%s",
962                  mainkey? "pub":"sub", nbits_from_pk( pk ),
963                  pubkey_letter( pk->pubkey_algo ), keystr_from_pk( pk ),
964                  datestr_from_pk( pk ), mainkey?" ":"");
965
966         if( mainkey ) {
967             /* and now list all userids with their signatures */
968             for( node = node->next; node; node = node->next ) {
969                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
970                     if( !any ) {
971                         if( node->pkt->pkt.signature->sig_class == 0x20 )
972                             puts("[revoked]");
973                         else
974                             putchar('\n');
975                         any = 1;
976                     }
977                     list_node(c,  node );
978                 }
979                 else if( node->pkt->pkttype == PKT_USER_ID ) {
980                     if( any ) {
981                         if( opt.with_colons )
982                             printf("%s:::::::::",
983                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
984                         else
985                             printf( "uid%*s", 28, "" );
986                     }
987                     print_userid( node->pkt );
988                     if( opt.with_colons )
989                         putchar(':');
990                     putchar('\n');
991                     if( opt.fingerprint && !any )
992                         print_fingerprint ( pk, 0 );
993                     if( opt.with_colons
994                         && node->next
995                         && node->next->pkt->pkttype == PKT_RING_TRUST ) {
996                         printf("rtv:2:%u:\n",
997                                node->next->pkt->pkt.ring_trust?
998                                node->next->pkt->pkt.ring_trust->trustval : 0);
999                     }
1000                     any=1;
1001                 }
1002                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1003                     if( !any ) {
1004                         putchar('\n');
1005                         any = 1;
1006                     }
1007                     list_node(c,  node );
1008                 }
1009             }
1010         }
1011         else
1012           {
1013             /* of subkey */
1014             if( pk->flags.revoked )
1015               {
1016                 printf(" [");
1017                 printf(_("revoked: %s"),revokestr_from_pk(pk));
1018                 printf("]");
1019               }
1020             else if( pk->expiredate )
1021               {
1022                 printf(" [");
1023                 printf(_("expires: %s"),expirestr_from_pk(pk));
1024                 printf("]");
1025               }
1026           }
1027
1028         if( !any )
1029             putchar('\n');
1030         if( !mainkey && opt.fingerprint > 1 )
1031             print_fingerprint( pk, 0 );
1032     }
1033     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
1034              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1035
1036       log_debug ("FIXME: No way to print secret key packets here\n");
1037       /* fixme: We may use a fucntion to trun a secret key packet into
1038          a public key one and use that here.  */
1039         /* PKT_secret_key *sk = node->pkt->pkt.secret_key; */
1040
1041         /* if( opt.with_colons ) */
1042         /*   { */
1043         /*     u32 keyid[2]; */
1044         /*     keyid_from_sk( sk, keyid ); */
1045         /*     printf("%s::%u:%d:%08lX%08lX:%s:%s:::", */
1046         /*         mainkey? "sec":"ssb", */
1047         /*         nbits_from_sk( sk ), */
1048         /*         sk->pubkey_algo, */
1049         /*         (ulong)keyid[0],(ulong)keyid[1], */
1050         /*         colon_datestr_from_sk( sk ), */
1051         /*         colon_strtime (sk->expiredate) */
1052         /*         /\* fixme: add LID *\/ ); */
1053         /*   } */
1054         /* else */
1055         /*   printf("%s  %4u%c/%s %s ", mainkey? "sec":"ssb", */
1056         /*       nbits_from_sk( sk ), pubkey_letter( sk->pubkey_algo ), */
1057         /*       keystr_from_sk( sk ), datestr_from_sk( sk )); */
1058         /* if( mainkey ) { */
1059         /*     /\* and now list all userids with their signatures *\/ */
1060         /*     for( node = node->next; node; node = node->next ) { */
1061         /*      if( node->pkt->pkttype == PKT_SIGNATURE ) { */
1062         /*          if( !any ) { */
1063         /*              if( node->pkt->pkt.signature->sig_class == 0x20 ) */
1064         /*                  puts("[revoked]"); */
1065         /*              else */
1066         /*                  putchar('\n'); */
1067         /*              any = 1; */
1068         /*          } */
1069         /*          list_node(c,  node ); */
1070         /*      } */
1071         /*      else if( node->pkt->pkttype == PKT_USER_ID ) { */
1072         /*          if( any ) { */
1073         /*              if( opt.with_colons ) */
1074         /*                  printf("%s:::::::::", */
1075         /*                    node->pkt->pkt.user_id->attrib_data?"uat":"uid"); */
1076         /*              else */
1077         /*                  printf( "uid%*s", 28, "" ); */
1078         /*          } */
1079         /*          print_userid( node->pkt ); */
1080         /*          if( opt.with_colons ) */
1081         /*              putchar(':'); */
1082         /*          putchar('\n'); */
1083         /*          if( opt.fingerprint && !any ) */
1084         /*              print_fingerprint( NULL, sk, 0 ); */
1085         /*          any=1; */
1086         /*      } */
1087         /*      else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) { */
1088         /*          if( !any ) { */
1089         /*              putchar('\n'); */
1090         /*              any = 1; */
1091         /*          } */
1092         /*          list_node(c,  node ); */
1093         /*      } */
1094         /*     } */
1095         /* } */
1096         /* if( !any ) */
1097         /*     putchar('\n'); */
1098         /* if( !mainkey && opt.fingerprint > 1 ) */
1099         /*     print_fingerprint( NULL, sk, 0 ); */
1100     }
1101     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
1102         PKT_signature *sig = node->pkt->pkt.signature;
1103         int is_selfsig = 0;
1104         int rc2=0;
1105         size_t n;
1106         char *p;
1107         int sigrc = ' ';
1108
1109         if( !opt.verbose )
1110             return;
1111
1112         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
1113             fputs("rev", stdout);
1114         else
1115             fputs("sig", stdout);
1116         if( opt.check_sigs ) {
1117             fflush(stdout);
1118             rc2=do_check_sig( c, node, &is_selfsig, NULL, NULL );
1119             switch (gpg_err_code (rc2)) {
1120               case 0:                        sigrc = '!'; break;
1121               case GPG_ERR_BAD_SIGNATURE:    sigrc = '-'; break;
1122               case GPG_ERR_NO_PUBKEY:
1123               case GPG_ERR_UNUSABLE_PUBKEY:  sigrc = '?'; break;
1124               default:                       sigrc = '%'; break;
1125             }
1126         }
1127         else {  /* check whether this is a self signature */
1128             u32 keyid[2];
1129
1130             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
1131                 || c->list->pkt->pkttype == PKT_SECRET_KEY )
1132               {
1133                 keyid_from_pk (c->list->pkt->pkt.public_key, keyid);
1134
1135                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
1136                   is_selfsig = 1;
1137               }
1138         }
1139         if( opt.with_colons ) {
1140             putchar(':');
1141             if( sigrc != ' ' )
1142                 putchar(sigrc);
1143             printf("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1144                    (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1145                    colon_datestr_from_sig(sig),
1146                    colon_expirestr_from_sig(sig));
1147
1148             if(sig->trust_depth || sig->trust_value)
1149               printf("%d %d",sig->trust_depth,sig->trust_value);
1150             printf(":");
1151
1152             if(sig->trust_regexp)
1153               es_write_sanitized (es_stdout,sig->trust_regexp,
1154                                   strlen(sig->trust_regexp), ":", NULL);
1155             printf(":");
1156         }
1157         else
1158           printf("%c       %s %s   ",
1159                  sigrc, keystr(sig->keyid), datestr_from_sig(sig));
1160         if( sigrc == '%' )
1161             printf("[%s] ", g10_errstr(rc2) );
1162         else if( sigrc == '?' )
1163             ;
1164         else if( is_selfsig ) {
1165             if( opt.with_colons )
1166                 putchar(':');
1167             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
1168             if( opt.with_colons )
1169                 putchar(':');
1170         }
1171         else if( !opt.fast_list_mode ) {
1172             p = get_user_id( sig->keyid, &n );
1173             es_write_sanitized (es_stdout, p, n,
1174                                 opt.with_colons?":":NULL, NULL );
1175             xfree(p);
1176         }
1177         if( opt.with_colons )
1178             printf(":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1179         putchar('\n');
1180     }
1181     else
1182         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
1183 }
1184
1185
1186
1187 int
1188 proc_packets (ctrl_t ctrl, void *anchor, IOBUF a )
1189 {
1190     int rc;
1191     CTX c = xmalloc_clear( sizeof *c );
1192
1193     c->ctrl = ctrl;
1194     c->anchor = anchor;
1195     rc = do_proc_packets( c, a );
1196     xfree( c );
1197     return rc;
1198 }
1199
1200
1201
1202 int
1203 proc_signature_packets (ctrl_t ctrl, void *anchor, IOBUF a,
1204                         strlist_t signedfiles, const char *sigfilename )
1205 {
1206     CTX c = xmalloc_clear( sizeof *c );
1207     int rc;
1208
1209     c->ctrl = ctrl;
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
1243 int
1244 proc_signature_packets_by_fd (ctrl_t ctrl,
1245                               void *anchor, IOBUF a, int signed_data_fd )
1246 {
1247   int rc;
1248   CTX c;
1249
1250   c = xtrycalloc (1, sizeof *c);
1251   if (!c)
1252     return gpg_error_from_syserror ();
1253
1254   c->ctrl = ctrl;
1255   c->anchor = anchor;
1256   c->sigs_only = 1;
1257
1258   c->signed_data.data_fd = signed_data_fd;
1259   c->signed_data.data_names = NULL;
1260   c->signed_data.used = (signed_data_fd != -1);
1261
1262   rc = do_proc_packets ( c, a );
1263
1264   /* If we have not encountered any signature we print an error
1265      messages, send a NODATA status back and return an error code.
1266      Using log_error is required because verify_files does not check
1267      error codes for each file but we want to terminate the process
1268      with an error. */
1269   if (!rc && !c->any.sig_seen)
1270     {
1271       write_status_text (STATUS_NODATA, "4");
1272       log_error (_("no signature found\n"));
1273       rc = gpg_error (GPG_ERR_NO_DATA);
1274     }
1275
1276   /* Propagate the signature seen flag upward. Do this only on success
1277      so that we won't issue the nodata status several times. */
1278   if (!rc && c->anchor && c->any.sig_seen)
1279     c->anchor->any.sig_seen = 1;
1280
1281   xfree ( c );
1282   return rc;
1283 }
1284
1285
1286 int
1287 proc_encryption_packets (ctrl_t ctrl, void *anchor, IOBUF a )
1288 {
1289     CTX c = xmalloc_clear( sizeof *c );
1290     int rc;
1291
1292     c->ctrl = ctrl;
1293     c->anchor = anchor;
1294     c->encrypt_only = 1;
1295     rc = do_proc_packets( c, a );
1296     xfree( c );
1297     return rc;
1298 }
1299
1300
1301 static int
1302 check_nesting (CTX c)
1303 {
1304   int level;
1305
1306   for (level=0; c; c = c->anchor)
1307     level++;
1308
1309   if (level > MAX_NESTING_DEPTH)
1310     {
1311       log_error ("input data with too deeply nested packets\n");
1312       write_status_text (STATUS_UNEXPECTED, "1");
1313       return GPG_ERR_BAD_DATA;
1314     }
1315   return 0;
1316 }
1317
1318
1319 static int
1320 do_proc_packets( CTX c, IOBUF a )
1321 {
1322     PACKET *pkt;
1323     int rc = 0;
1324     int any_data = 0;
1325     int newpkt;
1326
1327     rc = check_nesting (c);
1328     if (rc)
1329       return rc;
1330
1331     pkt = xmalloc( sizeof *pkt );
1332     c->iobuf = a;
1333     init_packet(pkt);
1334     while( (rc=parse_packet(a, pkt)) != -1 ) {
1335         any_data = 1;
1336         if( rc ) {
1337             free_packet(pkt);
1338             /* stop processing when an invalid packet has been encountered
1339              * but don't do so when we are doing a --list-packets. */
1340             if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
1341                 && opt.list_packets != 2 )
1342                 break;
1343             continue;
1344         }
1345         newpkt = -1;
1346         if( opt.list_packets ) {
1347             switch( pkt->pkttype ) {
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_COMPRESSED:  rc = proc_compressed( c, pkt ); break;
1353               default: newpkt = 0; break;
1354             }
1355         }
1356         else if( c->sigs_only ) {
1357             switch( pkt->pkttype ) {
1358               case PKT_PUBLIC_KEY:
1359               case PKT_SECRET_KEY:
1360               case PKT_USER_ID:
1361               case PKT_SYMKEY_ENC:
1362               case PKT_PUBKEY_ENC:
1363               case PKT_ENCRYPTED:
1364               case PKT_ENCRYPTED_MDC:
1365                 write_status_text( STATUS_UNEXPECTED, "0" );
1366                 rc = G10ERR_UNEXPECTED;
1367                 goto leave;
1368               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1369               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1370               case PKT_COMPRESSED:  rc = proc_compressed( c, pkt ); break;
1371               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1372               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1373               default: newpkt = 0; break;
1374             }
1375         }
1376         else if( c->encrypt_only ) {
1377             switch( pkt->pkttype ) {
1378               case PKT_PUBLIC_KEY:
1379               case PKT_SECRET_KEY:
1380               case PKT_USER_ID:
1381                 write_status_text( STATUS_UNEXPECTED, "0" );
1382                 rc = G10ERR_UNEXPECTED;
1383                 goto leave;
1384               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1385               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1386               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1387               case PKT_ENCRYPTED:
1388               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1389               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1390               case PKT_COMPRESSED:  rc = proc_compressed( c, pkt ); break;
1391               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1392               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1393               default: newpkt = 0; break;
1394             }
1395         }
1396         else {
1397             switch( pkt->pkttype ) {
1398               case PKT_PUBLIC_KEY:
1399               case PKT_SECRET_KEY:
1400                 release_list( c );
1401                 c->list = new_kbnode( pkt );
1402                 newpkt = 1;
1403                 break;
1404               case PKT_PUBLIC_SUBKEY:
1405               case PKT_SECRET_SUBKEY:
1406                 newpkt = add_subkey( c, pkt );
1407                 break;
1408               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
1409               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1410               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1411               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1412               case PKT_ENCRYPTED:
1413               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1414               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1415               case PKT_COMPRESSED:  rc = proc_compressed( c, pkt ); break;
1416               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1417               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1418               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
1419               default: newpkt = 0; break;
1420             }
1421         }
1422
1423         if (rc)
1424           goto leave;
1425
1426         /* This is a very ugly construct and frankly, I don't remember why
1427          * I used it.  Adding the MDC check here is a hack.
1428          * The right solution is to initiate another context for encrypted
1429          * packet and not to reuse the current one ...  It works right
1430          * when there is a compression packet inbetween which adds just
1431          * an extra layer.
1432          * Hmmm: Rewrite this whole module here??
1433          */
1434         if( pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC )
1435             c->any.data = (pkt->pkttype == PKT_PLAINTEXT);
1436
1437         if( newpkt == -1 )
1438             ;
1439         else if( newpkt ) {
1440             pkt = xmalloc( sizeof *pkt );
1441             init_packet(pkt);
1442         }
1443         else
1444             free_packet(pkt);
1445     }
1446     if( rc == G10ERR_INVALID_PACKET )
1447         write_status_text( STATUS_NODATA, "3" );
1448     if( any_data )
1449         rc = 0;
1450     else if( rc == -1 )
1451         write_status_text( STATUS_NODATA, "2" );
1452
1453
1454   leave:
1455     release_list( c );
1456     xfree(c->dek);
1457     free_packet( pkt );
1458     xfree( pkt );
1459     free_md_filter_context( &c->mfx );
1460     return rc;
1461 }
1462
1463
1464 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1465    of the notation data. */
1466 static pka_info_t *
1467 get_pka_address (PKT_signature *sig)
1468 {
1469   pka_info_t *pka = NULL;
1470   struct notation *nd,*notation;
1471
1472   notation=sig_to_notation(sig);
1473
1474   for(nd=notation;nd;nd=nd->next)
1475     {
1476       if(strcmp(nd->name,"pka-address@gnupg.org")!=0)
1477         continue; /* Not the notation we want. */
1478
1479       /* For now we only use the first valid PKA notation. In future
1480          we might want to keep additional PKA notations in a linked
1481          list. */
1482       if (is_valid_mailbox (nd->value))
1483         {
1484           pka = xmalloc (sizeof *pka + strlen(nd->value));
1485           pka->valid = 0;
1486           pka->checked = 0;
1487           pka->uri = NULL;
1488           strcpy (pka->email, nd->value);
1489           break;
1490         }
1491     }
1492
1493   free_notation(notation);
1494
1495   return pka;
1496 }
1497
1498
1499 /* Return the URI from a DNS PKA record.  If this record has already
1500    be retrieved for the signature we merely return it; if not we go
1501    out and try to get that DNS record. */
1502 static const char *
1503 pka_uri_from_sig (PKT_signature *sig)
1504 {
1505   if (!sig->flags.pka_tried)
1506     {
1507       assert (!sig->pka_info);
1508       sig->flags.pka_tried = 1;
1509       sig->pka_info = get_pka_address (sig);
1510       if (sig->pka_info)
1511         {
1512           char *uri;
1513
1514           uri = get_pka_info (sig->pka_info->email, sig->pka_info->fpr);
1515           if (uri)
1516             {
1517               sig->pka_info->valid = 1;
1518               if (!*uri)
1519                 xfree (uri);
1520               else
1521                 sig->pka_info->uri = uri;
1522             }
1523         }
1524     }
1525   return sig->pka_info? sig->pka_info->uri : NULL;
1526 }
1527
1528
1529 static int
1530 check_sig_and_print( CTX c, KBNODE node )
1531 {
1532   PKT_signature *sig = node->pkt->pkt.signature;
1533   const char *astr;
1534   int rc, is_expkey=0, is_revkey=0;
1535
1536   if (opt.skip_verify)
1537     {
1538       log_info(_("signature verification suppressed\n"));
1539       return 0;
1540     }
1541
1542   /* Check that the message composition is valid.
1543
1544      Per RFC-2440bis (-15) allowed:
1545
1546      S{1,n}           -- detached signature.
1547      S{1,n} P         -- old style PGP2 signature
1548      O{1,n} P S{1,n}  -- standard OpenPGP signature.
1549      C P S{1,n}       -- cleartext signature.
1550
1551
1552           O = One-Pass Signature packet.
1553           S = Signature packet.
1554           P = OpenPGP Message packet (Encrypted | Compressed | Literal)
1555                  (Note that the current rfc2440bis draft also allows
1556                   for a signed message but that does not work as it
1557                   introduces ambiguities.)
1558               We keep track of these packages using the marker packet
1559               CTRLPKT_PLAINTEXT_MARK.
1560           C = Marker packet for cleartext signatures.
1561
1562      We reject all other messages.
1563
1564      Actually we are calling this too often, i.e. for verification of
1565      each message but better have some duplicate work than to silently
1566      introduce a bug here.
1567   */
1568   {
1569     KBNODE n;
1570     int n_onepass, n_sig;
1571
1572 /*     log_debug ("checking signature packet composition\n"); */
1573 /*     dump_kbnode (c->list); */
1574
1575     n = c->list;
1576     assert (n);
1577     if ( n->pkt->pkttype == PKT_SIGNATURE )
1578       {
1579         /* This is either "S{1,n}" case (detached signature) or
1580            "S{1,n} P" (old style PGP2 signature). */
1581         for (n = n->next; n; n = n->next)
1582           if (n->pkt->pkttype != PKT_SIGNATURE)
1583             break;
1584         if (!n)
1585           ; /* Okay, this is a detached signature.  */
1586         else if (n->pkt->pkttype == PKT_GPG_CONTROL
1587                  && (n->pkt->pkt.gpg_control->control
1588                      == CTRLPKT_PLAINTEXT_MARK) )
1589           {
1590             if (n->next)
1591               goto ambiguous;  /* We only allow one P packet. */
1592           }
1593         else
1594           goto ambiguous;
1595       }
1596     else if (n->pkt->pkttype == PKT_ONEPASS_SIG)
1597       {
1598         /* This is the "O{1,n} P S{1,n}" case (standard signature). */
1599         for (n_onepass=1, n = n->next;
1600              n && n->pkt->pkttype == PKT_ONEPASS_SIG; n = n->next)
1601           n_onepass++;
1602         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1603                     && (n->pkt->pkt.gpg_control->control
1604                         == CTRLPKT_PLAINTEXT_MARK)))
1605           goto ambiguous;
1606         for (n_sig=0, n = n->next;
1607              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1608           n_sig++;
1609         if (!n_sig)
1610           goto ambiguous;
1611
1612         /* If we wanted to disallow multiple sig verification, we'd do
1613            something like this:
1614
1615            if (n && !opt.allow_multisig_verification)
1616              goto ambiguous;
1617
1618            However, now that we have --allow-multiple-messages, this
1619            can stay allowable as we can't get here unless multiple
1620            messages (i.e. multiple literals) are allowed. */
1621
1622         if (n_onepass != n_sig)
1623           {
1624             log_info ("number of one-pass packets does not match "
1625                       "number of signature packets\n");
1626             goto ambiguous;
1627           }
1628       }
1629     else if (n->pkt->pkttype == PKT_GPG_CONTROL
1630              && n->pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START )
1631       {
1632         /* This is the "C P S{1,n}" case (clear text signature). */
1633         n = n->next;
1634         if (!n || !(n->pkt->pkttype == PKT_GPG_CONTROL
1635                     && (n->pkt->pkt.gpg_control->control
1636                         == CTRLPKT_PLAINTEXT_MARK)))
1637           goto ambiguous;
1638         for (n_sig=0, n = n->next;
1639              n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
1640           n_sig++;
1641         if (n || !n_sig)
1642           goto ambiguous;
1643       }
1644     else
1645       {
1646       ambiguous:
1647         log_error(_("can't handle this ambiguous signature data\n"));
1648         return 0;
1649       }
1650
1651   }
1652
1653   /* (Indendation below not yet changed to GNU style.) */
1654
1655     astr = openpgp_pk_algo_name ( sig->pubkey_algo );
1656     if(keystrlen()>8)
1657       {
1658         log_info(_("Signature made %s\n"),asctimestamp(sig->timestamp));
1659         log_info(_("               using %s key %s\n"),
1660                  astr? astr: "?",keystr(sig->keyid));
1661       }
1662     else
1663       log_info(_("Signature made %s using %s key ID %s\n"),
1664                asctimestamp(sig->timestamp), astr? astr: "?",
1665                keystr(sig->keyid));
1666
1667     rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1668
1669     /* If the key isn't found, check for a preferred keyserver */
1670
1671     if(rc==G10ERR_NO_PUBKEY && sig->flags.pref_ks)
1672       {
1673         const byte *p;
1674         int seq=0;
1675         size_t n;
1676
1677         while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1678           {
1679             /* According to my favorite copy editor, in English
1680                grammar, you say "at" if the key is located on a web
1681                page, but "from" if it is located on a keyserver.  I'm
1682                not going to even try to make two strings here :) */
1683             log_info(_("Key available at: ") );
1684             print_utf8_buffer (log_get_stream(), p, n);
1685             log_printf ("\n");
1686
1687             if(opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1688                && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1689               {
1690                 struct keyserver_spec *spec;
1691
1692                 spec=parse_preferred_keyserver(sig);
1693                 if(spec)
1694                   {
1695                     int res;
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                     if(!res)
1701                       rc=do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1702                     free_keyserver_spec(spec);
1703
1704                     if(!rc)
1705                       break;
1706                   }
1707               }
1708           }
1709       }
1710
1711     /* If the preferred keyserver thing above didn't work, our second
1712        try is to use the URI from a DNS PKA record. */
1713     if ( rc == G10ERR_NO_PUBKEY
1714          && opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1715          && opt.keyserver_options.options&KEYSERVER_HONOR_PKA_RECORD)
1716       {
1717         const char *uri = pka_uri_from_sig (sig);
1718
1719         if (uri)
1720           {
1721             /* FIXME: We might want to locate the key using the
1722                fingerprint instead of the keyid. */
1723             int res;
1724             struct keyserver_spec *spec;
1725
1726             spec = parse_keyserver_uri (uri, 1, NULL, 0);
1727             if (spec)
1728               {
1729                 glo_ctrl.in_auto_key_retrieve++;
1730                 res = keyserver_import_keyid (c->ctrl, sig->keyid, spec);
1731                 glo_ctrl.in_auto_key_retrieve--;
1732                 free_keyserver_spec (spec);
1733                 if (!res)
1734                   rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1735               }
1736           }
1737       }
1738
1739     /* If the preferred keyserver thing above didn't work and we got
1740        no information from the DNS PKA, this is a third try. */
1741
1742     if( rc == G10ERR_NO_PUBKEY && opt.keyserver
1743         && opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE)
1744       {
1745         int res;
1746
1747         glo_ctrl.in_auto_key_retrieve++;
1748         res=keyserver_import_keyid (c->ctrl, sig->keyid, opt.keyserver );
1749         glo_ctrl.in_auto_key_retrieve--;
1750         if(!res)
1751           rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1752       }
1753
1754     if( !rc || gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE ) {
1755         KBNODE un, keyblock;
1756         int count=0, statno;
1757         char keyid_str[50];
1758         PKT_public_key *pk=NULL;
1759
1760         if(rc)
1761           statno=STATUS_BADSIG;
1762         else if(sig->flags.expired)
1763           statno=STATUS_EXPSIG;
1764         else if(is_expkey)
1765           statno=STATUS_EXPKEYSIG;
1766         else if(is_revkey)
1767           statno=STATUS_REVKEYSIG;
1768         else
1769           statno=STATUS_GOODSIG;
1770
1771         keyblock = get_pubkeyblock( sig->keyid );
1772
1773         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1774                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1775
1776         /* find and print the primary user ID */
1777         for( un=keyblock; un; un = un->next ) {
1778             char *p;
1779             int valid;
1780             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1781               {
1782                 pk=un->pkt->pkt.public_key;
1783                 continue;
1784               }
1785             if( un->pkt->pkttype != PKT_USER_ID )
1786                 continue;
1787             if ( !un->pkt->pkt.user_id->created )
1788                 continue;
1789             if ( un->pkt->pkt.user_id->is_revoked )
1790                 continue;
1791             if ( un->pkt->pkt.user_id->is_expired )
1792                 continue;
1793             if ( !un->pkt->pkt.user_id->is_primary )
1794                 continue;
1795             /* We want the textual primary user ID here */
1796             if ( un->pkt->pkt.user_id->attrib_data )
1797                 continue;
1798
1799             assert(pk);
1800
1801             /* Get it before we print anything to avoid interrupting
1802                the output with the "please do a --check-trustdb"
1803                line. */
1804             valid=get_validity(pk,un->pkt->pkt.user_id);
1805
1806             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1807             write_status_text_and_buffer (statno, keyid_str,
1808                                           un->pkt->pkt.user_id->name,
1809                                           un->pkt->pkt.user_id->len,
1810                                           -1 );
1811
1812             p=utf8_to_native(un->pkt->pkt.user_id->name,
1813                              un->pkt->pkt.user_id->len,0);
1814
1815             if(rc)
1816               log_info(_("BAD signature from \"%s\""),p);
1817             else if(sig->flags.expired)
1818               log_info(_("Expired signature from \"%s\""),p);
1819             else
1820               log_info(_("Good signature from \"%s\""),p);
1821
1822             xfree(p);
1823
1824             if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1825               log_printf (" [%s]\n",trust_value_to_string(valid));
1826             else
1827               log_printf ("\n");
1828             count++;
1829         }
1830         if( !count ) {  /* just in case that we have no valid textual
1831                            userid */
1832             char *p;
1833
1834             /* Try for an invalid textual userid */
1835             for( un=keyblock; un; un = un->next ) {
1836                 if( un->pkt->pkttype == PKT_USER_ID &&
1837                     !un->pkt->pkt.user_id->attrib_data )
1838                     break;
1839             }
1840
1841             /* Try for any userid at all */
1842             if(!un) {
1843                 for( un=keyblock; un; un = un->next ) {
1844                     if( un->pkt->pkttype == PKT_USER_ID )
1845                         break;
1846                 }
1847             }
1848
1849             if (opt.trust_model==TM_ALWAYS || !un)
1850                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1851
1852             write_status_text_and_buffer (statno, keyid_str,
1853                                           un? un->pkt->pkt.user_id->name:"[?]",
1854                                           un? un->pkt->pkt.user_id->len:3,
1855                                           -1 );
1856
1857             if(un)
1858               p=utf8_to_native(un->pkt->pkt.user_id->name,
1859                                un->pkt->pkt.user_id->len,0);
1860             else
1861               p=xstrdup("[?]");
1862
1863             if(rc)
1864               log_info(_("BAD signature from \"%s\""),p);
1865             else if(sig->flags.expired)
1866               log_info(_("Expired signature from \"%s\""),p);
1867             else
1868               log_info(_("Good signature from \"%s\""),p);
1869             if (opt.trust_model!=TM_ALWAYS && un)
1870               log_printf (" %s",_("[uncertain]") );
1871             log_printf ("\n");
1872         }
1873
1874         /* If we have a good signature and already printed
1875          * the primary user ID, print all the other user IDs */
1876         if ( count && !rc
1877              && !(opt.verify_options&VERIFY_SHOW_PRIMARY_UID_ONLY)) {
1878             char *p;
1879             for( un=keyblock; un; un = un->next ) {
1880                 if( un->pkt->pkttype != PKT_USER_ID )
1881                     continue;
1882                 if((un->pkt->pkt.user_id->is_revoked
1883                     || un->pkt->pkt.user_id->is_expired)
1884                    && !(opt.verify_options&VERIFY_SHOW_UNUSABLE_UIDS))
1885                   continue;
1886                 /* Only skip textual primaries */
1887                 if ( un->pkt->pkt.user_id->is_primary &&
1888                      !un->pkt->pkt.user_id->attrib_data )
1889                     continue;
1890
1891                 if(un->pkt->pkt.user_id->attrib_data)
1892                   {
1893                     dump_attribs (un->pkt->pkt.user_id, pk);
1894
1895                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1896                       show_photos(un->pkt->pkt.user_id->attribs,
1897                                   un->pkt->pkt.user_id->numattribs,
1898                                   pk ,un->pkt->pkt.user_id);
1899                   }
1900
1901                 p=utf8_to_native(un->pkt->pkt.user_id->name,
1902                                  un->pkt->pkt.user_id->len,0);
1903                 log_info(_("                aka \"%s\""),p);
1904                 xfree(p);
1905
1906                 if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1907                   {
1908                     const char *valid;
1909                     if(un->pkt->pkt.user_id->is_revoked)
1910                       valid=_("revoked");
1911                     else if(un->pkt->pkt.user_id->is_expired)
1912                       valid=_("expired");
1913                     else
1914                       valid=trust_value_to_string(get_validity(pk,
1915                                                                un->pkt->
1916                                                                pkt.user_id));
1917                     log_printf (" [%s]\n",valid);
1918                   }
1919                 else
1920                   log_printf ("\n");
1921             }
1922         }
1923         release_kbnode( keyblock );
1924
1925         if( !rc )
1926           {
1927             if(opt.verify_options&VERIFY_SHOW_POLICY_URLS)
1928               show_policy_url(sig,0,1);
1929             else
1930               show_policy_url(sig,0,2);
1931
1932             if(opt.verify_options&VERIFY_SHOW_KEYSERVER_URLS)
1933               show_keyserver_url(sig,0,1);
1934             else
1935               show_keyserver_url(sig,0,2);
1936
1937             if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
1938               show_notation(sig,0,1,
1939                         ((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)+
1940                         ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0));
1941             else
1942               show_notation(sig,0,2,0);
1943           }
1944
1945         if( !rc && is_status_enabled() ) {
1946             /* print a status response with the fingerprint */
1947             PKT_public_key *vpk = xmalloc_clear( sizeof *vpk );
1948
1949             if( !get_pubkey( vpk, sig->keyid ) ) {
1950                 byte array[MAX_FINGERPRINT_LEN], *p;
1951                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1952                 size_t i, n;
1953
1954                 bufp = buf;
1955                 fingerprint_from_pk( vpk, array, &n );
1956                 p = array;
1957                 for(i=0; i < n ; i++, p++, bufp += 2)
1958                     sprintf(bufp, "%02X", *p );
1959                 /* TODO: Replace the reserved '0' in the field below
1960                    with bits for status flags (policy url, notation,
1961                    etc.).  Remember to make the buffer larger to
1962                    match! */
1963                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1964                         strtimestamp( sig->timestamp ),
1965                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1966                         sig->version,sig->pubkey_algo,sig->digest_algo,
1967                         sig->sig_class);
1968                 bufp = bufp + strlen (bufp);
1969                 if (!vpk->flags.primary) {
1970                    u32 akid[2];
1971
1972                    akid[0] = vpk->main_keyid[0];
1973                    akid[1] = vpk->main_keyid[1];
1974                    free_public_key (vpk);
1975                    vpk = xmalloc_clear( sizeof *vpk );
1976                    if (get_pubkey (vpk, akid)) {
1977                      /* impossible error, we simply return a zeroed out fpr */
1978                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1979                      memset (array, 0, n);
1980                    }
1981                    else
1982                      fingerprint_from_pk( vpk, array, &n );
1983                 }
1984                 p = array;
1985                 for(i=0; i < n ; i++, p++, bufp += 2)
1986                     sprintf(bufp, "%02X", *p );
1987                 write_status_text( STATUS_VALIDSIG, buf );
1988             }
1989             free_public_key( vpk );
1990         }
1991
1992         if (!rc)
1993           {
1994             if(opt.verify_options&VERIFY_PKA_LOOKUPS)
1995               pka_uri_from_sig (sig); /* Make sure PKA info is available. */
1996             rc = check_signatures_trust( sig );
1997           }
1998
1999         if(sig->flags.expired)
2000           {
2001             log_info(_("Signature expired %s\n"),
2002                      asctimestamp(sig->expiredate));
2003             rc=G10ERR_GENERAL; /* need a better error here? */
2004           }
2005         else if(sig->expiredate)
2006           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
2007
2008         if(opt.verbose)
2009           log_info(_("%s signature, digest algorithm %s\n"),
2010                    sig->sig_class==0x00?_("binary"):
2011                    sig->sig_class==0x01?_("textmode"):_("unknown"),
2012                    gcry_md_algo_name (sig->digest_algo));
2013
2014         if( rc )
2015             g10_errors_seen = 1;
2016         if( opt.batch && rc )
2017             g10_exit(1);
2018     }
2019     else {
2020         char buf[50];
2021         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
2022                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
2023                      sig->pubkey_algo, sig->digest_algo,
2024                      sig->sig_class, (ulong)sig->timestamp, rc );
2025         write_status_text( STATUS_ERRSIG, buf );
2026         if( rc == G10ERR_NO_PUBKEY ) {
2027             buf[16] = 0;
2028             write_status_text( STATUS_NO_PUBKEY, buf );
2029         }
2030         if( rc != G10ERR_NOT_PROCESSED )
2031             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
2032     }
2033     return rc;
2034 }
2035
2036
2037 /****************
2038  * Process the tree which starts at node
2039  */
2040 static void
2041 proc_tree( CTX c, KBNODE node )
2042 {
2043     KBNODE n1;
2044     int rc;
2045
2046     if( opt.list_packets || opt.list_only )
2047         return;
2048
2049     /* we must skip our special plaintext marker packets here becuase
2050        they may be the root packet.  These packets are only used in
2051        addionla checks and skipping them here doesn't matter */
2052     while ( node
2053             && node->pkt->pkttype == PKT_GPG_CONTROL
2054             && node->pkt->pkt.gpg_control->control
2055                          == CTRLPKT_PLAINTEXT_MARK ) {
2056         node = node->next;
2057     }
2058     if (!node)
2059         return;
2060
2061     c->trustletter = ' ';
2062     if( node->pkt->pkttype == PKT_PUBLIC_KEY
2063         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2064         merge_keys_and_selfsig( node );
2065         list_node( c, node );
2066     }
2067     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
2068         merge_keys_and_selfsig( node );
2069         list_node( c, node );
2070     }
2071     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
2072         /* check all signatures */
2073         if( !c->any.data ) {
2074             int use_textmode = 0;
2075
2076             free_md_filter_context( &c->mfx );
2077             /* prepare to create all requested message digests */
2078             if (gcry_md_open (&c->mfx.md, 0, 0))
2079               BUG ();
2080
2081             /* fixme: why looking for the signature packet and not the
2082                one-pass packet? */
2083             for ( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
2084               {
2085                 gcry_md_enable (c->mfx.md,
2086                                 n1->pkt->pkt.signature->digest_algo);
2087               }
2088
2089             if (n1 && n1->pkt->pkt.onepass_sig->sig_class == 0x01)
2090                 use_textmode = 1;
2091
2092             /* Ask for file and hash it. */
2093             if( c->sigs_only ) {
2094                 if (c->signed_data.used && c->signed_data.data_fd != -1)
2095                     rc = hash_datafile_by_fd (c->mfx.md, NULL,
2096                                               c->signed_data.data_fd,
2097                                               use_textmode);
2098                 else
2099                     rc = hash_datafiles (c->mfx.md, NULL,
2100                                          c->signed_data.data_names,
2101                                          c->sigfilename,
2102                                          use_textmode );
2103             }
2104             else {
2105                 rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2106                                                 iobuf_get_real_fname(c->iobuf),
2107                                                 use_textmode );
2108             }
2109             if( rc ) {
2110                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
2111                 return;
2112             }
2113         }
2114         else if ( c->signed_data.used ) {
2115             log_error (_("not a detached signature\n") );
2116             return;
2117         }
2118
2119         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
2120             check_sig_and_print( c, n1 );
2121     }
2122     else if( node->pkt->pkttype == PKT_GPG_CONTROL
2123              && node->pkt->pkt.gpg_control->control
2124                 == CTRLPKT_CLEARSIGN_START ) {
2125         /* clear text signed message */
2126         if( !c->any.data ) {
2127             log_error("cleartext signature without data\n" );
2128             return;
2129         }
2130         else if ( c->signed_data.used ) {
2131             log_error (_("not a detached signature\n") );
2132             return;
2133         }
2134
2135         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
2136             check_sig_and_print( c, n1 );
2137     }
2138     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
2139         PKT_signature *sig = node->pkt->pkt.signature;
2140         int multiple_ok=1;
2141
2142         n1=find_next_kbnode(node, PKT_SIGNATURE);
2143         if(n1)
2144           {
2145             byte class=sig->sig_class;
2146             byte hash=sig->digest_algo;
2147
2148             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2149               {
2150                 /* We can't currently handle multiple signatures of
2151                    different classes or digests (we'd pretty much have
2152                    to run a different hash context for each), but if
2153                    they are all the same, make an exception. */
2154                 if(n1->pkt->pkt.signature->sig_class!=class
2155                    || n1->pkt->pkt.signature->digest_algo!=hash)
2156                   {
2157                     multiple_ok=0;
2158                     log_info(_("WARNING: multiple signatures detected.  "
2159                                "Only the first will be checked.\n"));
2160                     break;
2161                   }
2162               }
2163           }
2164
2165         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
2166             log_info(_("standalone signature of class 0x%02x\n"),
2167                                                     sig->sig_class);
2168         else if( !c->any.data ) {
2169             /* detached signature */
2170             free_md_filter_context( &c->mfx );
2171             if (gcry_md_open (&c->mfx.md, sig->digest_algo, 0))
2172               BUG ();
2173
2174             if( !opt.pgp2_workarounds )
2175                 ;
2176             else if( sig->digest_algo == DIGEST_ALGO_MD5
2177                      && is_RSA( sig->pubkey_algo ) ) {
2178                 /* enable a workaround for a pgp2 bug */
2179                 if (gcry_md_open (&c->mfx.md2, DIGEST_ALGO_MD5, 0))
2180                   BUG ();
2181             }
2182             else if( sig->digest_algo == DIGEST_ALGO_SHA1
2183                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
2184                      && sig->sig_class == 0x01 ) {
2185                 /* enable the workaround also for pgp5 when the detached
2186                  * signature has been created in textmode */
2187               if (gcry_md_open (&c->mfx.md2, sig->digest_algo, 0 ))
2188                 BUG ();
2189             }
2190 #if 0 /* workaround disabled */
2191             /* Here we have another hack to work around a pgp 2 bug
2192              * It works by not using the textmode for detached signatures;
2193              * this will let the first signature check (on md) fail
2194              * but the second one (on md2) which adds an extra CR should
2195              * then produce the "correct" hash.  This is very, very ugly
2196              * hack but it may help in some cases (and break others)
2197              */
2198                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
2199 #endif
2200             if ( DBG_HASHING ) {
2201                 gcry_md_debug( c->mfx.md, "verify" );
2202                 if ( c->mfx.md2  )
2203                     gcry_md_debug( c->mfx.md2, "verify2" );
2204             }
2205             if( c->sigs_only ) {
2206                 if (c->signed_data.used && c->signed_data.data_fd != -1)
2207                     rc = hash_datafile_by_fd (c->mfx.md, c->mfx.md2,
2208                                               c->signed_data.data_fd,
2209                                               (sig->sig_class == 0x01));
2210                 else
2211                     rc = hash_datafiles (c->mfx.md, c->mfx.md2,
2212                                          c->signed_data.data_names,
2213                                          c->sigfilename,
2214                                          (sig->sig_class == 0x01));
2215             }
2216             else {
2217                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
2218                                                 iobuf_get_real_fname(c->iobuf),
2219                                                 (sig->sig_class == 0x01) );
2220             }
2221             if( rc ) {
2222                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
2223                 return;
2224             }
2225         }
2226         else if ( c->signed_data.used ) {
2227             log_error (_("not a detached signature\n") );
2228             return;
2229         }
2230         else if (!opt.quiet)
2231             log_info(_("old style (PGP 2.x) signature\n"));
2232
2233         if(multiple_ok)
2234           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
2235             check_sig_and_print( c, n1 );
2236         else
2237           check_sig_and_print( c, node );
2238     }
2239     else {
2240         dump_kbnode (c->list);
2241         log_error(_("invalid root packet detected in proc_tree()\n"));
2242         dump_kbnode (node);
2243     }
2244 }