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