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