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