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