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