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