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