gpg: Fix indendation of check_sig_and_print.
[gnupg.git] / g10 / mainproc.c
1 /* mainproc.c - handle packets
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2009 Free Software Foundation, Inc.
4  * Copyright (C) 2013, 2014 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #include <time.h>
28
29 #include "gpg.h"
30 #include "util.h"
31 #include "packet.h"
32 #include "iobuf.h"
33 #include "options.h"
34 #include "keydb.h"
35 #include "filter.h"
36 #include "main.h"
37 #include "status.h"
38 #include "i18n.h"
39 #include "trustdb.h"
40 #include "keyserver-internal.h"
41 #include "photoid.h"
42 #include "pka.h"
43
44
45 /* Put an upper limit on nested packets.  The 32 is an arbitrary
46    value, a much lower should actually be sufficient.  */
47 #define MAX_NESTING_DEPTH 32
48
49
50 struct kidlist_item {
51     struct kidlist_item *next;
52     u32 kid[2];
53     int pubkey_algo;
54     int reason;
55 };
56
57
58 /****************
59  * Structure to hold the context
60  */
61 typedef struct mainproc_context *CTX;
62 struct mainproc_context
63 {
64   ctrl_t ctrl;
65   struct mainproc_context *anchor;  /* May be useful in the future. */
66   PKT_public_key *last_pubkey;
67   PKT_user_id     *last_user_id;
68   md_filter_context_t mfx;
69   int sigs_only;    /* Process only signatures and reject all other stuff. */
70   int encrypt_only; /* Process only encryption messages. */
71
72   /* Name of the file with the complete signature or the file with the
73      detached signature.  This is currently only used to deduce the
74      file name of the data file if that has not been given. */
75   const char *sigfilename;
76
77   /* A structure to describe the signed data in case of a detached
78      signature. */
79   struct
80   {
81     /* A file descriptor of the the signed data.  Only used if not -1. */
82     int data_fd;
83     /* A list of filenames with the data files or NULL. This is only
84        used if DATA_FD is -1. */
85     strlist_t data_names;
86     /* Flag to indicated that either one of the next previous fields
87        is used.  This is only needed for better readability. */
88     int used;
89   } signed_data;
90
91   DEK *dek;
92   int last_was_session_key;
93   KBNODE list;      /* The current list of packets. */
94   IOBUF iobuf;      /* Used to get the filename etc. */
95   int trustletter;  /* Temporary usage in list_node. */
96   ulong symkeys;
97   struct kidlist_item *pkenc_list; /* List of encryption packets. */
98   struct {
99     unsigned int sig_seen:1;      /* Set to true if a signature packet
100                                      has been seen. */
101     unsigned int data:1;          /* Any data packet seen */
102     unsigned int uncompress_failed:1;
103   } any;
104 };
105
106
107 static int do_proc_packets( CTX c, IOBUF a );
108 static void list_node( CTX c, KBNODE node );
109 static void proc_tree( CTX c, KBNODE node );
110 static int literals_seen;
111
112 void
113 reset_literals_seen(void)
114 {
115   literals_seen=0;
116 }
117
118 static void
119 release_list( CTX c )
120 {
121     if( !c->list )
122         return;
123     proc_tree(c, c->list );
124     release_kbnode( c->list );
125     while( c->pkenc_list ) {
126         struct kidlist_item *tmp = c->pkenc_list->next;
127         xfree( c->pkenc_list );
128         c->pkenc_list = tmp;
129     }
130     c->pkenc_list = NULL;
131     c->list = NULL;
132     c->any.data = 0;
133     c->any.uncompress_failed = 0;
134     c->last_was_session_key = 0;
135     xfree(c->dek); c->dek = NULL;
136 }
137
138
139 static int
140 add_onepass_sig( CTX c, PACKET *pkt )
141 {
142   KBNODE node;
143
144   if ( c->list ) /* add another packet */
145     add_kbnode( c->list, new_kbnode( pkt ));
146   else /* insert the first one */
147     c->list = node = new_kbnode( pkt );
148
149   return 1;
150 }
151
152
153 static int
154 add_gpg_control( CTX c, PACKET *pkt )
155 {
156     if ( pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START ) {
157         /* New clear text signature.
158          * Process the last one and reset everything */
159         release_list(c);
160     }
161
162     if( c->list )  /* add another packet */
163         add_kbnode( c->list, new_kbnode( pkt ));
164     else /* insert the first one */
165         c->list = new_kbnode( pkt );
166
167     return 1;
168 }
169
170
171
172 static int
173 add_user_id( CTX c, PACKET *pkt )
174 {
175     if( !c->list ) {
176         log_error("orphaned user ID\n" );
177         return 0;
178     }
179     add_kbnode( c->list, new_kbnode( pkt ) );
180     return 1;
181 }
182
183 static int
184 add_subkey( CTX c, PACKET *pkt )
185 {
186     if( !c->list ) {
187         log_error("subkey w/o mainkey\n" );
188         return 0;
189     }
190     add_kbnode( c->list, new_kbnode( pkt ) );
191     return 1;
192 }
193
194 static int
195 add_ring_trust( CTX c, PACKET *pkt )
196 {
197     if( !c->list ) {
198         log_error("ring trust w/o key\n" );
199         return 0;
200     }
201     add_kbnode( c->list, new_kbnode( pkt ) );
202     return 1;
203 }
204
205
206 static int
207 add_signature( CTX c, PACKET *pkt )
208 {
209     KBNODE node;
210
211     c->any.sig_seen = 1;
212     if( pkt->pkttype == PKT_SIGNATURE && !c->list ) {
213         /* This is the first signature for the following datafile.
214          * GPG does not write such packets; instead it always uses
215          * onepass-sig packets.  The drawback of PGP's method
216          * of prepending the signature to the data is
217          * that it is not possible to make a signature from data read
218          * from stdin.  (GPG is able to read PGP stuff anyway.) */
219         node = new_kbnode( pkt );
220         c->list = node;
221         return 1;
222     }
223     else if( !c->list )
224         return 0; /* oops (invalid packet sequence)*/
225     else if( !c->list->pkt )
226         BUG();  /* so nicht */
227
228     /* add a new signature node id at the end */
229     node = new_kbnode( pkt );
230     add_kbnode( c->list, node );
231     return 1;
232 }
233
234 static int
235 symkey_decrypt_seskey( DEK *dek, byte *seskey, size_t slen )
236 {
237   gcry_cipher_hd_t hd;
238
239   if(slen < 17 || slen > 33)
240     {
241       log_error ( _("weird size for an encrypted session key (%d)\n"),
242                   (int)slen);
243       return G10ERR_BAD_KEY;
244     }
245
246   if (openpgp_cipher_open (&hd, dek->algo, GCRY_CIPHER_MODE_CFB, 1))
247       BUG ();
248   if (gcry_cipher_setkey ( hd, dek->key, dek->keylen ))
249     BUG ();
250   gcry_cipher_setiv ( hd, NULL, 0 );
251   gcry_cipher_decrypt ( hd, seskey, slen, NULL, 0 );
252   gcry_cipher_close ( hd );
253
254   /* Now we replace the dek components with the real session key to
255      decrypt the contents of the sequencing packet. */
256
257   dek->keylen=slen-1;
258   dek->algo=seskey[0];
259
260   if(dek->keylen > DIM(dek->key))
261     BUG ();
262
263   memcpy(dek->key, seskey + 1, dek->keylen);
264
265   /*log_hexdump( "thekey", dek->key, dek->keylen );*/
266
267   return 0;
268 }
269
270 static void
271 proc_symkey_enc( CTX c, PACKET *pkt )
272 {
273     PKT_symkey_enc *enc;
274
275     enc = pkt->pkt.symkey_enc;
276     if (!enc)
277         log_error ("invalid symkey encrypted packet\n");
278     else if(!c->dek)
279       {
280         int algo = enc->cipher_algo;
281         const char *s = openpgp_cipher_algo_name (algo);
282
283         if (!openpgp_cipher_test_algo (algo))
284           {
285             if(!opt.quiet)
286               {
287                 if(enc->seskeylen)
288                   log_info(_("%s encrypted session key\n"), s );
289                 else
290                   log_info(_("%s encrypted data\n"), s );
291               }
292           }
293         else
294           log_error(_("encrypted with unknown algorithm %d\n"), algo );
295
296         if(openpgp_md_test_algo (enc->s2k.hash_algo))
297           {
298             log_error(_("passphrase generated with unknown digest"
299                         " algorithm %d\n"),enc->s2k.hash_algo);
300             s=NULL;
301           }
302
303         c->last_was_session_key = 2;
304         if(!s || opt.list_only)
305           goto leave;
306
307         if(opt.override_session_key)
308           {
309             c->dek = xmalloc_clear( sizeof *c->dek );
310             if(get_override_session_key(c->dek, opt.override_session_key))
311               {
312                 xfree(c->dek);
313                 c->dek = NULL;
314               }
315           }
316         else
317           {
318             c->dek = passphrase_to_dek (NULL, 0, algo, &enc->s2k, 3,
319                                         NULL, NULL);
320             if(c->dek)
321               {
322                 c->dek->symmetric=1;
323
324                 /* FIXME: This doesn't work perfectly if a symmetric
325                    key comes before a public key in the message - if
326                    the user doesn't know the passphrase, then there is
327                    a chance that the "decrypted" algorithm will happen
328                    to be a valid one, which will make the returned dek
329                    appear valid, so we won't try any public keys that
330                    come later. */
331                 if(enc->seskeylen)
332                   {
333                     if(symkey_decrypt_seskey(c->dek, enc->seskey,
334                                              enc->seskeylen))
335                       {
336                         xfree(c->dek);
337                         c->dek=NULL;
338                       }
339                   }
340                 else
341                   c->dek->algo_info_printed = 1;
342               }
343           }
344       }
345
346  leave:
347     c->symkeys++;
348     free_packet(pkt);
349 }
350
351 static void
352 proc_pubkey_enc( CTX c, PACKET *pkt )
353 {
354     PKT_pubkey_enc *enc;
355     int result = 0;
356
357     /* check whether the secret key is available and store in this case */
358     c->last_was_session_key = 1;
359     enc = pkt->pkt.pubkey_enc;
360     /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
361     /* Hmmm: why do I have this algo check here - anyway there is
362      * function to check it. */
363     if( opt.verbose )
364         log_info(_("public key is %s\n"), keystr(enc->keyid) );
365
366     if( is_status_enabled() ) {
367         char buf[50];
368         /* FIXME: For ECC support we need to map the OpenPGP algo
369            number to the Libgcrypt definef one.  This is due a
370            chicken-egg problem: We need to have code in libgcrypt for
371            a new algorithm so to implement a proposed new algorithm
372            before the IANA will finally assign an OpenPGP
373            indentifier.  */
374         snprintf (buf, sizeof buf, "%08lX%08lX %d 0",
375                 (ulong)enc->keyid[0], (ulong)enc->keyid[1], enc->pubkey_algo );
376         write_status_text( STATUS_ENC_TO, buf );
377     }
378
379     if( !opt.list_only && opt.override_session_key ) {
380         /* It does not make much sense to store the session key in
381          * secure memory because it has already been passed on the
382          * command line and the GCHQ knows about it.  */
383         c->dek = xmalloc_clear( sizeof *c->dek );
384         result = get_override_session_key ( c->dek, opt.override_session_key );
385         if ( result ) {
386             xfree(c->dek); c->dek = NULL;
387         }
388     }
389     else if( is_ELGAMAL(enc->pubkey_algo)
390              || enc->pubkey_algo == PUBKEY_ALGO_DSA
391              || enc->pubkey_algo == PUBKEY_ALGO_ECDSA
392              || enc->pubkey_algo == PUBKEY_ALGO_EDDSA
393              || enc->pubkey_algo == PUBKEY_ALGO_ECDH
394              || is_RSA(enc->pubkey_algo)
395              || enc->pubkey_algo == PUBKEY_ALGO_ELGAMAL) {
396       /* Note that we also allow type 20 Elgamal keys for decryption.
397          There are still a couple of those keys in active use as a
398          subkey.  */
399
400       /* FIXME: Store this all in a list and process it later so that
401          we can prioritize what key to use.  This gives a better user
402          experience if wildcard keyids are used.  */
403         if ( !c->dek && ((!enc->keyid[0] && !enc->keyid[1])
404                           || opt.try_all_secrets
405                           || have_secret_key_with_kid (enc->keyid)) ) {
406             if( opt.list_only )
407                 result = -1;
408             else {
409                 c->dek = xmalloc_secure_clear( sizeof *c->dek );
410                 if( (result = get_session_key( enc, c->dek )) ) {
411                     /* error: delete the DEK */
412                     xfree(c->dek); c->dek = NULL;
413                 }
414             }
415         }
416         else
417             result = G10ERR_NO_SECKEY;
418     }
419     else
420         result = G10ERR_PUBKEY_ALGO;
421
422     if( result == -1 )
423         ;
424     else
425       {
426         /* store it for later display */
427         struct kidlist_item *x = xmalloc( sizeof *x );
428         x->kid[0] = enc->keyid[0];
429         x->kid[1] = enc->keyid[1];
430         x->pubkey_algo = enc->pubkey_algo;
431         x->reason = result;
432         x->next = c->pkenc_list;
433         c->pkenc_list = x;
434
435         if( !result && opt.verbose > 1 )
436           log_info( _("public key encrypted data: good DEK\n") );
437       }
438
439     free_packet(pkt);
440 }
441
442
443
444 /****************
445  * Print the list of public key encrypted packets which we could
446  * not decrypt.
447  */
448 static void
449 print_pkenc_list( struct kidlist_item *list, int failed )
450 {
451     for( ; list; list = list->next ) {
452         PKT_public_key *pk;
453         const char *algstr;
454
455         if ( failed && !list->reason )
456             continue;
457         if ( !failed && list->reason )
458             continue;
459
460         algstr = openpgp_pk_algo_name ( list->pubkey_algo );
461         pk = xmalloc_clear( sizeof *pk );
462
463         if( !algstr )
464             algstr = "[?]";
465         pk->pubkey_algo = list->pubkey_algo;
466         if( !get_pubkey( pk, list->kid ) )
467           {
468             char *p;
469             log_info( _("encrypted with %u-bit %s key, ID %s, created %s\n"),
470                       nbits_from_pk( pk ), algstr, keystr_from_pk(pk),
471                       strtimestamp(pk->timestamp) );
472             p=get_user_id_native(list->kid);
473             log_printf (_("      \"%s\"\n"),p);
474             xfree(p);
475           }
476         else
477           log_info(_("encrypted with %s key, ID %s\n"),
478                    algstr,keystr(list->kid));
479
480         free_public_key( pk );
481
482         if( list->reason == G10ERR_NO_SECKEY ) {
483             if( is_status_enabled() ) {
484                 char buf[20];
485                 snprintf (buf, sizeof buf, "%08lX%08lX",
486                           (ulong)list->kid[0], (ulong)list->kid[1]);
487                 write_status_text( STATUS_NO_SECKEY, buf );
488             }
489         }
490         else if (list->reason)
491           {
492             log_info(_("public key decryption failed: %s\n"),
493                                                 g10_errstr(list->reason));
494             write_status_error ("pkdecrypt_failed", list->reason);
495           }
496     }
497 }
498
499
500 static void
501 proc_encrypted( CTX c, PACKET *pkt )
502 {
503     int result = 0;
504
505     if (!opt.quiet)
506       {
507         if(c->symkeys>1)
508           log_info(_("encrypted with %lu passphrases\n"),c->symkeys);
509         else if(c->symkeys==1)
510           log_info(_("encrypted with 1 passphrase\n"));
511         print_pkenc_list ( c->pkenc_list, 1 );
512         print_pkenc_list ( c->pkenc_list, 0 );
513       }
514
515     /* FIXME: Figure out the session key by looking at all pkenc packets. */
516
517
518     write_status( STATUS_BEGIN_DECRYPTION );
519
520     /*log_debug("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
521     if( opt.list_only )
522         result = -1;
523     else if( !c->dek && !c->last_was_session_key ) {
524         int algo;
525         STRING2KEY s2kbuf, *s2k = NULL;
526
527         if(opt.override_session_key)
528           {
529             c->dek = xmalloc_clear( sizeof *c->dek );
530             result=get_override_session_key(c->dek, opt.override_session_key);
531             if(result)
532               {
533                 xfree(c->dek);
534                 c->dek = NULL;
535               }
536           }
537         else
538           {
539             /* Assume this is old style conventional encrypted data. */
540             algo = opt.def_cipher_algo;
541             if ( algo )
542               log_info (_("assuming %s encrypted data\n"),
543                         openpgp_cipher_algo_name (algo));
544             else if ( openpgp_cipher_test_algo (CIPHER_ALGO_IDEA) )
545               {
546                 algo = opt.def_cipher_algo;
547                 if (!algo)
548                   algo = opt.s2k_cipher_algo;
549                 log_info (_("IDEA cipher unavailable, "
550                             "optimistically attempting to use %s instead\n"),
551                           openpgp_cipher_algo_name (algo));
552               }
553             else
554               {
555                 algo = CIPHER_ALGO_IDEA;
556                 if (!opt.s2k_digest_algo)
557                   {
558                     /* If no digest is given we assume MD5 */
559                     s2kbuf.mode = 0;
560                     s2kbuf.hash_algo = DIGEST_ALGO_MD5;
561                     s2k = &s2kbuf;
562                   }
563                 log_info (_("assuming %s encrypted data\n"), "IDEA");
564               }
565
566             c->dek = passphrase_to_dek ( NULL, 0, algo, s2k, 3, NULL, NULL );
567             if (c->dek)
568               c->dek->algo_info_printed = 1;
569           }
570     }
571     else if( !c->dek )
572         result = G10ERR_NO_SECKEY;
573
574     if (!result)
575       result = decrypt_data (c->ctrl, c, pkt->pkt.encrypted, c->dek );
576
577     if( result == -1 )
578         ;
579     else if( !result || (gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE
580                          && opt.ignore_mdc_error)) {
581         write_status( STATUS_DECRYPTION_OKAY );
582         if( opt.verbose > 1 )
583             log_info(_("decryption okay\n"));
584         if( pkt->pkt.encrypted->mdc_method && !result )
585             write_status( STATUS_GOODMDC );
586         else if(!opt.no_mdc_warn)
587             log_info (_("WARNING: message was not integrity protected\n"));
588     }
589     else if( result == G10ERR_BAD_SIGN ) {
590         glo_ctrl.lasterr = result;
591         log_error(_("WARNING: encrypted message has been manipulated!\n"));
592         write_status( STATUS_BADMDC );
593         write_status( STATUS_DECRYPTION_FAILED );
594     }
595     else {
596         if (gpg_err_code (result) == GPG_ERR_BAD_KEY
597             && *c->dek->s2k_cacheid != '\0')
598           {
599             log_debug(_("cleared passphrase cached with ID: %s\n"),
600                       c->dek->s2k_cacheid);
601             passphrase_clear_cache (NULL, c->dek->s2k_cacheid, 0);
602           }
603         glo_ctrl.lasterr = result;
604         write_status( STATUS_DECRYPTION_FAILED );
605         log_error(_("decryption failed: %s\n"), g10_errstr(result));
606         /* Hmmm: does this work when we have encrypted using multiple
607          * ways to specify the session key (symmmetric and PK)*/
608     }
609     xfree(c->dek); c->dek = NULL;
610     free_packet(pkt);
611     c->last_was_session_key = 0;
612     write_status( STATUS_END_DECRYPTION );
613 }
614
615
616 static void
617 proc_plaintext( CTX c, PACKET *pkt )
618 {
619     PKT_plaintext *pt = pkt->pkt.plaintext;
620     int any, clearsig, only_md5, rc;
621     KBNODE n;
622
623     literals_seen++;
624
625     if( pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8 ) )
626         log_info(_("NOTE: sender requested \"for-your-eyes-only\"\n"));
627     else if( opt.verbose )
628         log_info(_("original file name='%.*s'\n"), pt->namelen, pt->name);
629     free_md_filter_context( &c->mfx );
630     if (gcry_md_open (&c->mfx.md, 0, 0))
631       BUG ();
632     /* fixme: we may need to push the textfilter if we have sigclass 1
633      * and no armoring - Not yet tested
634      * Hmmm, why don't we need it at all if we have sigclass 1
635      * Should we assume that plaintext in mode 't' has always sigclass 1??
636      * See: Russ Allbery's mail 1999-02-09
637      */
638     any = clearsig = only_md5 = 0;
639     for(n=c->list; n; n = n->next )
640       {
641         if( n->pkt->pkttype == PKT_ONEPASS_SIG )
642           {
643             /* For the onepass signature case */
644             if( n->pkt->pkt.onepass_sig->digest_algo )
645               {
646                 gcry_md_enable (c->mfx.md,
647                                 n->pkt->pkt.onepass_sig->digest_algo);
648                 if( !any && n->pkt->pkt.onepass_sig->digest_algo
649                     == DIGEST_ALGO_MD5 )
650                   only_md5 = 1;
651                 else
652                   only_md5 = 0;
653                 any = 1;
654               }
655             if( n->pkt->pkt.onepass_sig->sig_class != 0x01 )
656               only_md5 = 0;
657           }
658         else if( n->pkt->pkttype == PKT_GPG_CONTROL
659                  && n->pkt->pkt.gpg_control->control
660                  == CTRLPKT_CLEARSIGN_START )
661           {
662             /* For the clearsigned message case */
663             size_t datalen = n->pkt->pkt.gpg_control->datalen;
664             const byte *data = n->pkt->pkt.gpg_control->data;
665
666             /* check that we have at least the sigclass and one hash */
667             if ( datalen < 2 )
668               log_fatal("invalid control packet CTRLPKT_CLEARSIGN_START\n");
669             /* Note that we don't set the clearsig flag for not-dash-escaped
670              * documents */
671             clearsig = (*data == 0x01);
672             for( data++, datalen--; datalen; datalen--, data++ )
673                 gcry_md_enable (c->mfx.md, *data);
674             any = 1;
675             break;  /* Stop here as one-pass signature packets are not
676                        expected.  */
677           }
678         else if(n->pkt->pkttype==PKT_SIGNATURE)
679           {
680             /* For the SIG+LITERAL case that PGP used to use. */
681             gcry_md_enable ( c->mfx.md, n->pkt->pkt.signature->digest_algo );
682             any=1;
683           }
684       }
685
686     if( !any && !opt.skip_verify )
687       {
688         /* This is for the old GPG LITERAL+SIG case.  It's not legal
689            according to 2440, so hopefully it won't come up that
690            often.  There is no good way to specify what algorithms to
691            use in that case, so these three are the historical
692            answer. */
693         gcry_md_enable( c->mfx.md, DIGEST_ALGO_RMD160 );
694         gcry_md_enable( c->mfx.md, DIGEST_ALGO_SHA1 );
695         gcry_md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
696       }
697     if( opt.pgp2_workarounds && only_md5 && !opt.skip_verify ) {
698         /* This is a kludge to work around a bug in pgp2.  It does only
699          * catch those mails which are armored.  To catch the non-armored
700          * pgp mails we could see whether there is the signature packet
701          * in front of the plaintext.  If someone needs this, send me a patch.
702          */
703       if ( gcry_md_open (&c->mfx.md2, DIGEST_ALGO_MD5, 0) )
704         BUG ();
705     }
706     if ( DBG_HASHING ) {
707         gcry_md_debug ( c->mfx.md, "verify" );
708         if ( c->mfx.md2  )
709             gcry_md_debug ( c->mfx.md2, "verify2" );
710     }
711
712     rc=0;
713
714     if (literals_seen>1)
715       {
716         log_info (_("WARNING: multiple plaintexts seen\n"));
717
718         if (!opt.flags.allow_multiple_messages)
719           {
720             write_status_text (STATUS_ERROR, "proc_pkt.plaintext 89_BAD_DATA");
721             log_inc_errorcount ();
722             rc = gpg_error (GPG_ERR_UNEXPECTED);
723           }
724       }
725
726     if(!rc)
727       {
728         rc = handle_plaintext( pt, &c->mfx, c->sigs_only, clearsig );
729         if ( gpg_err_code (rc) == GPG_ERR_EACCES && !c->sigs_only )
730           {
731             /* Can't write output but we hash it anyway to check the
732                signature. */
733             rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
734           }
735       }
736
737     if( rc )
738         log_error( "handle plaintext failed: %s\n", g10_errstr(rc));
739     free_packet(pkt);
740     c->last_was_session_key = 0;
741
742     /* We add a marker control packet instead of the plaintext packet.
743      * This is so that we can later detect invalid packet sequences.
744      */
745     n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK, NULL, 0));
746     if (c->list)
747         add_kbnode (c->list, n);
748     else
749         c->list = n;
750 }
751
752
753 static int
754 proc_compressed_cb( IOBUF a, void *info )
755 {
756   if ( ((CTX)info)->signed_data.used
757        && ((CTX)info)->signed_data.data_fd != -1)
758     return proc_signature_packets_by_fd (((CTX)info)->ctrl, info, a,
759                                          ((CTX)info)->signed_data.data_fd);
760   else
761     return proc_signature_packets (((CTX)info)->ctrl, info, a,
762                                    ((CTX)info)->signed_data.data_names,
763                                    ((CTX)info)->sigfilename );
764 }
765
766 static int
767 proc_encrypt_cb (IOBUF a, void *info )
768 {
769   CTX c = info;
770   return proc_encryption_packets (c->ctrl, info, a );
771 }
772
773 static int
774 proc_compressed( CTX c, PACKET *pkt )
775 {
776   PKT_compressed *zd = pkt->pkt.compressed;
777   int rc;
778
779   /*printf("zip: compressed data packet\n");*/
780   if (c->sigs_only)
781     rc = handle_compressed (c->ctrl, c, zd, proc_compressed_cb, c);
782   else if( c->encrypt_only )
783     rc = handle_compressed (c->ctrl, c, zd, proc_encrypt_cb, c);
784   else
785     rc = handle_compressed (c->ctrl, c, zd, NULL, NULL);
786
787   if (gpg_err_code (rc) == GPG_ERR_BAD_DATA)
788     {
789       if  (!c->any.uncompress_failed)
790         {
791           CTX cc;
792
793           for (cc=c; cc; cc = cc->anchor)
794             cc->any.uncompress_failed = 1;
795           log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
796         }
797     }
798   else if (rc)
799     log_error ("uncompressing failed: %s\n", gpg_strerror (rc));
800
801   free_packet(pkt);
802   c->last_was_session_key = 0;
803   return rc;
804 }
805
806 /****************
807  * check the signature
808  * Returns: 0 = valid signature or an error code
809  */
810 static int
811 do_check_sig( CTX c, KBNODE node, int *is_selfsig,
812               int *is_expkey, int *is_revkey )
813 {
814     PKT_signature *sig;
815     gcry_md_hd_t md = NULL, md2 = NULL;
816     int algo, rc;
817
818     assert( node->pkt->pkttype == PKT_SIGNATURE );
819     if( is_selfsig )
820         *is_selfsig = 0;
821     sig = node->pkt->pkt.signature;
822
823     algo = sig->digest_algo;
824     rc = openpgp_md_test_algo(algo);
825     if (rc)
826       return rc;
827
828     if( sig->sig_class == 0x00 ) {
829         if( c->mfx.md )
830           {
831             if (gcry_md_copy (&md, c->mfx.md ))
832               BUG ();
833           }
834         else /* detached signature */
835           {
836             /* signature_check() will enable the md*/
837             if (gcry_md_open (&md, 0, 0 ))
838               BUG ();
839           }
840     }
841     else if( sig->sig_class == 0x01 ) {
842         /* how do we know that we have to hash the (already hashed) text
843          * in canonical mode ??? (calculating both modes???) */
844         if( c->mfx.md ) {
845             if (gcry_md_copy (&md, c->mfx.md ))
846               BUG ();
847             if( c->mfx.md2 && gcry_md_copy (&md2, c->mfx.md2 ))
848               BUG ();
849         }
850         else { /* detached signature */
851             log_debug("Do we really need this here?");
852             /* signature_check() will enable the md*/
853             if (gcry_md_open (&md, 0, 0 ))
854               BUG ();
855             if (gcry_md_open (&md2, 0, 0 ))
856               BUG ();
857         }
858     }
859     else if( (sig->sig_class&~3) == 0x10
860              || sig->sig_class == 0x18
861              || sig->sig_class == 0x1f
862              || sig->sig_class == 0x20
863              || sig->sig_class == 0x28
864              || sig->sig_class == 0x30  ) {
865         if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
866             || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
867             return check_key_signature( c->list, node, is_selfsig );
868         }
869         else if( sig->sig_class == 0x20 ) {
870             log_error (_("standalone revocation - "
871                          "use \"gpg --import\" to apply\n"));
872             return G10ERR_NOT_PROCESSED;
873         }
874         else {
875             log_error("invalid root packet for sigclass %02x\n",
876                                                         sig->sig_class);
877             return G10ERR_SIG_CLASS;
878         }
879     }
880     else
881         return G10ERR_SIG_CLASS;
882     rc = signature_check2( sig, md, NULL, is_expkey, is_revkey, NULL );
883     if( gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE && md2 )
884         rc = signature_check2( sig, md2, NULL, is_expkey, is_revkey, NULL );
885     gcry_md_close(md);
886     gcry_md_close(md2);
887
888     return rc;
889 }
890
891
892 static void
893 print_userid( PACKET *pkt )
894 {
895     if( !pkt )
896         BUG();
897     if( pkt->pkttype != PKT_USER_ID ) {
898         printf("ERROR: unexpected packet type %d", pkt->pkttype );
899         return;
900     }
901     if( opt.with_colons )
902       {
903         if(pkt->pkt.user_id->attrib_data)
904           printf("%u %lu",
905                  pkt->pkt.user_id->numattribs,
906                  pkt->pkt.user_id->attrib_len);
907         else
908           es_write_sanitized (es_stdout, pkt->pkt.user_id->name,
909                               pkt->pkt.user_id->len, ":", NULL);
910       }
911     else
912         print_utf8_buffer (es_stdout, pkt->pkt.user_id->name,
913                            pkt->pkt.user_id->len );
914 }
915
916
917 /****************
918  * List the certificate in a user friendly way
919  */
920
921 static void
922 list_node( CTX c, KBNODE node )
923 {
924     int 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   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 (gpg_err_code (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 grammar,
1679              you say "at" if the key is located on a web page, but
1680              "from" if it is located on a keyserver.  I'm not going to
1681              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 (gpg_err_code (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 (gpg_err_code (rc) == G10ERR_NO_PUBKEY
1742       && opt.keyserver
1743       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE))
1744     {
1745       int res;
1746
1747       glo_ctrl.in_auto_key_retrieve++;
1748       res=keyserver_import_keyid (c->ctrl, sig->keyid, opt.keyserver );
1749       glo_ctrl.in_auto_key_retrieve--;
1750       if (!res)
1751         rc = do_check_sig (c, node, NULL, &is_expkey, &is_revkey );
1752     }
1753
1754   if (!rc || gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
1755     {
1756       kbnode_t un, keyblock;
1757       int count = 0;
1758       int 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       snprintf (keyid_str, sizeof 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         {
1781           char *p;
1782           int valid;
1783
1784           if (un->pkt->pkttype==PKT_PUBLIC_KEY)
1785             {
1786               pk=un->pkt->pkt.public_key;
1787               continue;
1788             }
1789           if (un->pkt->pkttype != PKT_USER_ID)
1790             continue;
1791           if (!un->pkt->pkt.user_id->created)
1792             continue;
1793           if (un->pkt->pkt.user_id->is_revoked)
1794             continue;
1795           if (un->pkt->pkt.user_id->is_expired)
1796             continue;
1797           if (!un->pkt->pkt.user_id->is_primary)
1798             continue;
1799           /* We want the textual primary user ID here */
1800           if (un->pkt->pkt.user_id->attrib_data)
1801             continue;
1802
1803           assert (pk);
1804
1805           /* Get it before we print anything to avoid interrupting the
1806              output with the "please do a --check-trustdb" line. */
1807           valid = get_validity (pk, un->pkt->pkt.user_id);
1808
1809           keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1810           write_status_text_and_buffer (statno, keyid_str,
1811                                         un->pkt->pkt.user_id->name,
1812                                         un->pkt->pkt.user_id->len,
1813                                         -1);
1814
1815           p = utf8_to_native (un->pkt->pkt.user_id->name,
1816                               un->pkt->pkt.user_id->len, 0);
1817
1818           if (rc)
1819             log_info (_("BAD signature from \"%s\""), p);
1820           else if (sig->flags.expired)
1821             log_info (_("Expired signature from \"%s\""), p);
1822           else
1823             log_info (_("Good signature from \"%s\""), p);
1824
1825           xfree(p);
1826
1827           if (opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1828             log_printf (" [%s]\n",trust_value_to_string(valid));
1829           else
1830             log_printf ("\n");
1831           count++;
1832         }
1833
1834       if (!count)  /* Just in case that we have no valid textual userid */
1835         {
1836           char *p;
1837
1838           /* Try for an invalid textual userid */
1839           for (un=keyblock; un; un = un->next)
1840             {
1841               if (un->pkt->pkttype == PKT_USER_ID
1842                   && !un->pkt->pkt.user_id->attrib_data)
1843                 break;
1844             }
1845
1846           /* Try for any userid at all */
1847           if (!un)
1848             {
1849               for (un=keyblock; un; un = un->next)
1850                 {
1851                   if (un->pkt->pkttype == PKT_USER_ID)
1852                     break;
1853                 }
1854             }
1855
1856           if (opt.trust_model==TM_ALWAYS || !un)
1857             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1858
1859           write_status_text_and_buffer (statno, keyid_str,
1860                                         un? un->pkt->pkt.user_id->name:"[?]",
1861                                         un? un->pkt->pkt.user_id->len:3,
1862                                         -1 );
1863
1864           if (un)
1865             p= utf8_to_native (un->pkt->pkt.user_id->name,
1866                                un->pkt->pkt.user_id->len, 0);
1867           else
1868             p = xstrdup ("[?]");
1869
1870           if (rc)
1871             log_info (_("BAD signature from \"%s\""), p);
1872           else if (sig->flags.expired)
1873             log_info (_("Expired signature from \"%s\""), p);
1874           else
1875             log_info (_("Good signature from \"%s\""), p);
1876           if (opt.trust_model != TM_ALWAYS && un)
1877             log_printf (" %s",_("[uncertain]") );
1878           log_printf ("\n");
1879         }
1880
1881       /* If we have a good signature and already printed
1882        * the primary user ID, print all the other user IDs */
1883       if (count
1884           && !rc
1885           && !(opt.verify_options & VERIFY_SHOW_PRIMARY_UID_ONLY))
1886         {
1887           char *p;
1888           for( un=keyblock; un; un = un->next)
1889             {
1890               if (un->pkt->pkttype != PKT_USER_ID)
1891                 continue;
1892               if ((un->pkt->pkt.user_id->is_revoked
1893                    || un->pkt->pkt.user_id->is_expired)
1894                   && !(opt.verify_options & VERIFY_SHOW_UNUSABLE_UIDS))
1895                 continue;
1896               /* Only skip textual primaries */
1897               if (un->pkt->pkt.user_id->is_primary
1898                   && !un->pkt->pkt.user_id->attrib_data )
1899                 continue;
1900
1901               if (un->pkt->pkt.user_id->attrib_data)
1902                 {
1903                   dump_attribs (un->pkt->pkt.user_id, pk);
1904
1905                   if (opt.verify_options&VERIFY_SHOW_PHOTOS)
1906                     show_photos (un->pkt->pkt.user_id->attribs,
1907                                  un->pkt->pkt.user_id->numattribs,
1908                                  pk ,un->pkt->pkt.user_id);
1909                 }
1910
1911               p = utf8_to_native (un->pkt->pkt.user_id->name,
1912                                   un->pkt->pkt.user_id->len, 0);
1913               log_info (_("                aka \"%s\""), p);
1914               xfree (p);
1915
1916               if ((opt.verify_options & VERIFY_SHOW_UID_VALIDITY))
1917                 {
1918                   const char *valid;
1919
1920                   if (un->pkt->pkt.user_id->is_revoked)
1921                     valid = _("revoked");
1922                   else if (un->pkt->pkt.user_id->is_expired)
1923                     valid = _("expired");
1924                   else
1925                     valid = (trust_value_to_string
1926                              (get_validity (pk, un->pkt->pkt.user_id)));
1927                   log_printf (" [%s]\n",valid);
1928                 }
1929               else
1930                 log_printf ("\n");
1931             }
1932         }
1933       release_kbnode( keyblock );
1934
1935       if (!rc)
1936         {
1937           if ((opt.verify_options & VERIFY_SHOW_POLICY_URLS))
1938             show_policy_url (sig, 0, 1);
1939           else
1940             show_policy_url (sig, 0, 2);
1941
1942           if ((opt.verify_options & VERIFY_SHOW_KEYSERVER_URLS))
1943             show_keyserver_url (sig, 0, 1);
1944           else
1945             show_keyserver_url (sig, 0, 2);
1946
1947           if ((opt.verify_options & VERIFY_SHOW_NOTATIONS))
1948             show_notation
1949               (sig, 0, 1,
1950                (((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)
1951                 + ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0)));
1952           else
1953             show_notation (sig, 0, 2, 0);
1954         }
1955
1956       if (!rc && is_status_enabled ())
1957         {
1958           /* Print a status response with the fingerprint. */
1959           PKT_public_key *vpk = xmalloc_clear (sizeof *vpk);
1960
1961           if (!get_pubkey (vpk, sig->keyid))
1962             {
1963               byte array[MAX_FINGERPRINT_LEN], *p;
1964               char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1965               size_t i, n;
1966
1967               bufp = buf;
1968               fingerprint_from_pk (vpk, array, &n);
1969               p = array;
1970               for(i=0; i < n ; i++, p++, bufp += 2)
1971                 sprintf (bufp, "%02X", *p );
1972               /* TODO: Replace the reserved '0' in the field below
1973                  with bits for status flags (policy url, notation,
1974                  etc.).  Remember to make the buffer larger to match! */
1975               sprintf (bufp, " %s %lu %lu %d 0 %d %d %02X ",
1976                        strtimestamp( sig->timestamp ),
1977                        (ulong)sig->timestamp,(ulong)sig->expiredate,
1978                        sig->version,sig->pubkey_algo,sig->digest_algo,
1979                        sig->sig_class);
1980               bufp = bufp + strlen (bufp);
1981               if (!vpk->flags.primary)
1982                 {
1983                   u32 akid[2];
1984
1985                   akid[0] = vpk->main_keyid[0];
1986                   akid[1] = vpk->main_keyid[1];
1987                   free_public_key (vpk);
1988                   vpk = xmalloc_clear (sizeof *vpk);
1989                   if (get_pubkey (vpk, akid))
1990                     {
1991                       /* Impossible error, we simply return a zeroed out fpr */
1992                       n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1993                       memset (array, 0, n);
1994                     }
1995                   else
1996                     fingerprint_from_pk( vpk, array, &n );
1997                 }
1998               p = array;
1999               for (i=0; i < n ; i++, p++, bufp += 2)
2000                 sprintf(bufp, "%02X", *p );
2001               write_status_text (STATUS_VALIDSIG, buf);
2002             }
2003           free_public_key (vpk);
2004         }
2005
2006       if (!rc)
2007         {
2008           if ((opt.verify_options & VERIFY_PKA_LOOKUPS))
2009             pka_uri_from_sig (sig); /* Make sure PKA info is available. */
2010           rc = check_signatures_trust (sig);
2011         }
2012
2013       if (sig->flags.expired)
2014         {
2015           log_info (_("Signature expired %s\n"), asctimestamp(sig->expiredate));
2016           rc = G10ERR_GENERAL; /* need a better error here? */
2017         }
2018       else if (sig->expiredate)
2019         log_info (_("Signature expires %s\n"), asctimestamp(sig->expiredate));
2020
2021       if (opt.verbose)
2022         log_info (_("%s signature, digest algorithm %s\n"),
2023                   sig->sig_class==0x00?_("binary"):
2024                   sig->sig_class==0x01?_("textmode"):_("unknown"),
2025                   gcry_md_algo_name (sig->digest_algo));
2026
2027       if (rc)
2028         g10_errors_seen = 1;
2029       if (opt.batch && rc)
2030         g10_exit (1);
2031     }
2032   else
2033     {
2034       char buf[50];
2035
2036       snprintf (buf, sizeof buf, "%08lX%08lX %d %d %02x %lu %d",
2037                 (ulong)sig->keyid[0], (ulong)sig->keyid[1],
2038                 sig->pubkey_algo, sig->digest_algo,
2039                 sig->sig_class, (ulong)sig->timestamp, rc);
2040       write_status_text (STATUS_ERRSIG, buf);
2041       if (gpg_err_code (rc) == G10ERR_NO_PUBKEY)
2042         {
2043           buf[16] = 0;
2044           write_status_text (STATUS_NO_PUBKEY, buf);
2045         }
2046       if (gpg_err_code (rc) != G10ERR_NOT_PROCESSED)
2047         log_error (_("Can't check signature: %s\n"), g10_errstr(rc));
2048     }
2049
2050   return rc;
2051 }
2052
2053
2054 /****************
2055  * Process the tree which starts at node
2056  */
2057 static void
2058 proc_tree( CTX c, KBNODE node )
2059 {
2060     KBNODE n1;
2061     int rc;
2062
2063     if( opt.list_packets || opt.list_only )
2064         return;
2065
2066     /* we must skip our special plaintext marker packets here becuase
2067        they may be the root packet.  These packets are only used in
2068        addionla checks and skipping them here doesn't matter */
2069     while ( node
2070             && node->pkt->pkttype == PKT_GPG_CONTROL
2071             && node->pkt->pkt.gpg_control->control
2072                          == CTRLPKT_PLAINTEXT_MARK ) {
2073         node = node->next;
2074     }
2075     if (!node)
2076         return;
2077
2078     c->trustletter = ' ';
2079     if( node->pkt->pkttype == PKT_PUBLIC_KEY
2080         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2081         merge_keys_and_selfsig( node );
2082         list_node( c, node );
2083     }
2084     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
2085         merge_keys_and_selfsig( node );
2086         list_node( c, node );
2087     }
2088     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
2089         /* check all signatures */
2090         if( !c->any.data ) {
2091             int use_textmode = 0;
2092
2093             free_md_filter_context( &c->mfx );
2094             /* prepare to create all requested message digests */
2095             if (gcry_md_open (&c->mfx.md, 0, 0))
2096               BUG ();
2097
2098             /* fixme: why looking for the signature packet and not the
2099                one-pass packet? */
2100             for ( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
2101               {
2102                 gcry_md_enable (c->mfx.md,
2103                                 n1->pkt->pkt.signature->digest_algo);
2104               }
2105
2106             if (n1 && n1->pkt->pkt.onepass_sig->sig_class == 0x01)
2107                 use_textmode = 1;
2108
2109             /* Ask for file and hash it. */
2110             if( c->sigs_only ) {
2111                 if (c->signed_data.used && c->signed_data.data_fd != -1)
2112                     rc = hash_datafile_by_fd (c->mfx.md, NULL,
2113                                               c->signed_data.data_fd,
2114                                               use_textmode);
2115                 else
2116                     rc = hash_datafiles (c->mfx.md, NULL,
2117                                          c->signed_data.data_names,
2118                                          c->sigfilename,
2119                                          use_textmode );
2120             }
2121             else {
2122                 rc = ask_for_detached_datafile (c->mfx.md, c->mfx.md2,
2123                                                 iobuf_get_real_fname(c->iobuf),
2124                                                 use_textmode );
2125             }
2126             if( rc ) {
2127                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
2128                 return;
2129             }
2130         }
2131         else if ( c->signed_data.used ) {
2132             log_error (_("not a detached signature\n") );
2133             return;
2134         }
2135
2136         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
2137             check_sig_and_print( c, n1 );
2138     }
2139     else if( node->pkt->pkttype == PKT_GPG_CONTROL
2140              && node->pkt->pkt.gpg_control->control
2141                 == CTRLPKT_CLEARSIGN_START ) {
2142         /* clear text signed message */
2143         if( !c->any.data ) {
2144             log_error("cleartext signature without data\n" );
2145             return;
2146         }
2147         else if ( c->signed_data.used ) {
2148             log_error (_("not a detached signature\n") );
2149             return;
2150         }
2151
2152         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
2153             check_sig_and_print( c, n1 );
2154     }
2155     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
2156         PKT_signature *sig = node->pkt->pkt.signature;
2157         int multiple_ok=1;
2158
2159         n1=find_next_kbnode(node, PKT_SIGNATURE);
2160         if(n1)
2161           {
2162             byte class=sig->sig_class;
2163             byte hash=sig->digest_algo;
2164
2165             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
2166               {
2167                 /* We can't currently handle multiple signatures of
2168                    different classes or digests (we'd pretty much have
2169                    to run a different hash context for each), but if
2170                    they are all the same, make an exception. */
2171                 if(n1->pkt->pkt.signature->sig_class!=class
2172                    || n1->pkt->pkt.signature->digest_algo!=hash)
2173                   {
2174                     multiple_ok=0;
2175                     log_info(_("WARNING: multiple signatures detected.  "
2176                                "Only the first will be checked.\n"));
2177                     break;
2178                   }
2179               }
2180           }
2181
2182         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
2183             log_info(_("standalone signature of class 0x%02x\n"),
2184                                                     sig->sig_class);
2185         else if( !c->any.data ) {
2186             /* detached signature */
2187             free_md_filter_context( &c->mfx );
2188             if (gcry_md_open (&c->mfx.md, sig->digest_algo, 0))
2189               BUG ();
2190
2191             if( !opt.pgp2_workarounds )
2192                 ;
2193             else if( sig->digest_algo == DIGEST_ALGO_MD5
2194                      && is_RSA( sig->pubkey_algo ) ) {
2195                 /* enable a workaround for a pgp2 bug */
2196                 if (gcry_md_open (&c->mfx.md2, DIGEST_ALGO_MD5, 0))
2197                   BUG ();
2198             }
2199             else if( sig->digest_algo == DIGEST_ALGO_SHA1
2200                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
2201                      && sig->sig_class == 0x01 ) {
2202                 /* enable the workaround also for pgp5 when the detached
2203                  * signature has been created in textmode */
2204               if (gcry_md_open (&c->mfx.md2, sig->digest_algo, 0 ))
2205                 BUG ();
2206             }
2207 #if 0 /* workaround disabled */
2208             /* Here we have another hack to work around a pgp 2 bug
2209              * It works by not using the textmode for detached signatures;
2210              * this will let the first signature check (on md) fail
2211              * but the second one (on md2) which adds an extra CR should
2212              * then produce the "correct" hash.  This is very, very ugly
2213              * hack but it may help in some cases (and break others)
2214              */
2215                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
2216 #endif
2217             if ( DBG_HASHING ) {
2218                 gcry_md_debug( c->mfx.md, "verify" );
2219                 if ( c->mfx.md2  )
2220                     gcry_md_debug( c->mfx.md2, "verify2" );
2221             }
2222             if( c->sigs_only ) {
2223                 if (c->signed_data.used && c->signed_data.data_fd != -1)
2224                     rc = hash_datafile_by_fd (c->mfx.md, c->mfx.md2,
2225                                               c->signed_data.data_fd,
2226                                               (sig->sig_class == 0x01));
2227                 else
2228                     rc = hash_datafiles (c->mfx.md, c->mfx.md2,
2229                                          c->signed_data.data_names,
2230                                          c->sigfilename,
2231                                          (sig->sig_class == 0x01));
2232             }
2233             else {
2234                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
2235                                                 iobuf_get_real_fname(c->iobuf),
2236                                                 (sig->sig_class == 0x01) );
2237             }
2238             if( rc ) {
2239                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
2240                 return;
2241             }
2242         }
2243         else if ( c->signed_data.used ) {
2244             log_error (_("not a detached signature\n") );
2245             return;
2246         }
2247         else if (!opt.quiet)
2248             log_info(_("old style (PGP 2.x) signature\n"));
2249
2250         if(multiple_ok)
2251           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
2252             check_sig_and_print( c, n1 );
2253         else
2254           check_sig_and_print( c, node );
2255     }
2256     else {
2257         dump_kbnode (c->list);
2258         log_error(_("invalid root packet detected in proc_tree()\n"));
2259         dump_kbnode (node);
2260     }
2261 }