* keygen.c (keygen_set_std_prefs): Build the default preferences list at
[gnupg.git] / g10 / mainproc.c
1 /* mainproc.c - handle packets
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #include <time.h>
28
29 #include "packet.h"
30 #include "iobuf.h"
31 #include "memory.h"
32 #include "options.h"
33 #include "util.h"
34 #include "cipher.h"
35 #include "keydb.h"
36 #include "filter.h"
37 #include "main.h"
38 #include "status.h"
39 #include "i18n.h"
40 #include "trustdb.h"
41 #include "keyserver-internal.h"
42 #include "photoid.h"
43
44
45 struct kidlist_item {
46     struct kidlist_item *next;
47     u32 kid[2];
48     int pubkey_algo;
49     int reason;
50 };
51
52
53 /****************
54  * Structure to hold the context
55  */
56 typedef struct mainproc_context *CTX;
57 struct mainproc_context {
58     struct mainproc_context *anchor;  /* may be useful in the future */
59     PKT_public_key *last_pubkey;
60     PKT_secret_key *last_seckey;
61     PKT_user_id     *last_user_id;
62     md_filter_context_t mfx;
63     int sigs_only;   /* process only signatures and reject all other stuff */
64     int encrypt_only; /* process only encrytion messages */
65     STRLIST signed_data;
66     const char *sigfilename;
67     DEK *dek;
68     int last_was_session_key;
69     KBNODE list;   /* the current list of packets */
70     int have_data;
71     IOBUF iobuf;    /* used to get the filename etc. */
72     int trustletter; /* temp usage in list_node */
73     ulong symkeys;
74     struct kidlist_item *pkenc_list;    /* list of encryption packets */
75     struct {
76         int op;
77         int stop_now;
78     } pipemode;
79 };
80
81
82 static int do_proc_packets( CTX c, IOBUF a );
83
84 static void list_node( CTX c, KBNODE node );
85 static void proc_tree( CTX c, KBNODE node );
86
87
88 static void
89 release_list( CTX c )
90 {
91     if( !c->list )
92         return;
93     proc_tree(c, c->list );
94     release_kbnode( c->list );
95     while( c->pkenc_list ) {
96         struct kidlist_item *tmp = c->pkenc_list->next;
97         m_free( c->pkenc_list );
98         c->pkenc_list = tmp;
99     }
100     c->pkenc_list = NULL;
101     c->list = NULL;
102     c->have_data = 0;
103     c->last_was_session_key = 0;
104     c->pipemode.op = 0;
105     c->pipemode.stop_now = 0;
106     m_free(c->dek); c->dek = NULL;
107 }
108
109
110 static int
111 add_onepass_sig( CTX c, PACKET *pkt )
112 {
113     KBNODE node;
114
115     if( c->list ) { /* add another packet */
116         /* We can only append another onepass packet if the list
117          * does contain only onepass packets */
118         for( node=c->list; node && node->pkt->pkttype == PKT_ONEPASS_SIG;
119              node = node->next )
120             ;
121         if( node ) {
122             /* this is not the case, so we flush the current thing and 
123              * allow this packet to start a new verification thing */
124            release_list( c );
125            c->list = new_kbnode( pkt );
126         }
127         else
128            add_kbnode( c->list, new_kbnode( pkt ));
129     }
130     else /* insert the first one */
131         c->list = node = new_kbnode( pkt );
132
133     return 1;
134 }
135
136
137 static int
138 add_gpg_control( CTX c, PACKET *pkt )
139 {
140     if ( pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START ) {
141         /* New clear text signature.
142          * Process the last one and reset everything */
143         release_list(c);
144     }   
145     else if ( pkt->pkt.gpg_control->control == CTRLPKT_PIPEMODE ) {
146         /* Pipemode control packet */
147         if ( pkt->pkt.gpg_control->datalen < 2 ) 
148             log_fatal ("invalid pipemode control packet length\n");
149         if (pkt->pkt.gpg_control->data[0] == 1) {
150             /* start the whole thing */
151             assert ( !c->list ); /* we should be in a pretty virgin state */
152             assert ( !c->pipemode.op );
153             c->pipemode.op = pkt->pkt.gpg_control->data[1];
154         }
155         else if (pkt->pkt.gpg_control->data[0] == 2) {
156             /* the signed material follows in a plaintext packet */
157             assert ( c->pipemode.op == 'B' );
158         }
159         else if (pkt->pkt.gpg_control->data[0] == 3) {
160             assert ( c->pipemode.op == 'B' );
161             release_list (c);
162             /* and tell the outer loop to terminate */
163             c->pipemode.stop_now = 1;
164         }
165         else 
166             log_fatal ("invalid pipemode control packet code\n");
167         return 0; /* no need to store the packet */
168     }   
169
170     if( c->list )  /* add another packet */
171         add_kbnode( c->list, new_kbnode( pkt ));
172     else /* insert the first one */
173         c->list = new_kbnode( pkt );
174
175     return 1;
176 }
177
178
179
180 static int
181 add_user_id( CTX c, PACKET *pkt )
182 {
183     if( !c->list ) {
184         log_error("orphaned user ID\n" );
185         return 0;
186     }
187     add_kbnode( c->list, new_kbnode( pkt ) );
188     return 1;
189 }
190
191 static int
192 add_subkey( CTX c, PACKET *pkt )
193 {
194     if( !c->list ) {
195         log_error("subkey w/o mainkey\n" );
196         return 0;
197     }
198     add_kbnode( c->list, new_kbnode( pkt ) );
199     return 1;
200 }
201
202 static int
203 add_ring_trust( CTX c, PACKET *pkt )
204 {
205     if( !c->list ) {
206         log_error("ring trust w/o key\n" );
207         return 0;
208     }
209     add_kbnode( c->list, new_kbnode( pkt ) );
210     return 1;
211 }
212
213
214 static int
215 add_signature( CTX c, PACKET *pkt )
216 {
217     KBNODE node;
218
219     if( pkt->pkttype == PKT_SIGNATURE && !c->list ) {
220         /* This is the first signature for the following datafile.
221          * GPG does not write such packets; instead it always uses
222          * onepass-sig packets.  The drawback of PGP's method
223          * of prepending the signature to the data is
224          * that it is not possible to make a signature from data read
225          * from stdin.  (GPG is able to read PGP stuff anyway.) */
226         node = new_kbnode( pkt );
227         c->list = node;
228         return 1;
229     }
230     else if( !c->list )
231         return 0; /* oops (invalid packet sequence)*/
232     else if( !c->list->pkt )
233         BUG();  /* so nicht */
234
235     /* add a new signature node id at the end */
236     node = new_kbnode( pkt );
237     add_kbnode( c->list, node );
238     return 1;
239 }
240
241 static int
242 symkey_decrypt_seskey( DEK *dek, byte *seskey, size_t slen )
243 {
244     CIPHER_HANDLE hd;
245     int n;
246
247     if ( slen < 17 || slen > 33 ) {
248         log_error ( _("weird size for an encrypted session key (%d)\n"),
249                     (int)slen);
250         return G10ERR_BAD_KEY;
251     }
252     hd = cipher_open( dek->algo, CIPHER_MODE_CFB, 1 );
253     cipher_setkey( hd, dek->key, dek->keylen );
254     cipher_setiv( hd, NULL, 0 );
255     cipher_decrypt( hd, seskey, seskey, slen );
256     cipher_close( hd );
257     /* check first byte (the cipher algo) */
258     if(check_cipher_algo(seskey[0]))
259       {
260         /* There is no way to tell the difference here between a bad
261            passphrase and a cipher algorithm that we don't have. */
262         log_error(_("bad passphrase or unknown cipher algorithm (%d)\n"),
263                   seskey[0]);
264         if(seskey[0]==CIPHER_ALGO_IDEA)
265           idea_cipher_warn(0);
266         return G10ERR_PASSPHRASE;
267       }
268     n = cipher_get_keylen (seskey[0]) / 8;
269     if (n > DIM(dek->key))
270          BUG ();
271     /* now we replace the dek components with the real session key
272        to decrypt the contents of the sequencing packet. */
273     dek->keylen = cipher_get_keylen( seskey[0] ) / 8;
274     dek->algo = seskey[0];
275     memcpy( dek->key, seskey + 1, dek->keylen );
276     /*log_hexdump( "thekey", dek->key, dek->keylen );*/
277
278     return 0;
279 }   
280
281 static void
282 proc_symkey_enc( CTX c, PACKET *pkt )
283 {
284     PKT_symkey_enc *enc;
285
286     enc = pkt->pkt.symkey_enc;
287     if (!enc)
288         log_error ("invalid symkey encrypted packet\n");
289     else if(!c->dek)
290       {
291         int algo = enc->cipher_algo;
292         const char *s = cipher_algo_to_string (algo);
293
294         if(s)
295           {
296             if(!opt.quiet)
297               {
298                 if(enc->seskeylen)
299                   log_info(_("%s encrypted session key\n"), s );
300                 else
301                   log_info(_("%s encrypted data\n"), s );
302               }
303           }
304         else
305           log_error(_("encrypted with unknown algorithm %d\n"), algo );
306
307         c->last_was_session_key = 2;
308         if(!s || opt.list_only)
309           goto leave;
310
311         if(opt.override_session_key)
312           {
313             c->dek = m_alloc_clear( sizeof *c->dek );
314             if(get_override_session_key(c->dek, opt.override_session_key))
315               {
316                 m_free(c->dek);
317                 c->dek = NULL;
318               }
319           }
320         else
321           {
322             c->dek=passphrase_to_dek(NULL, 0, algo, &enc->s2k, 0, NULL, NULL);
323
324             if(c->dek)
325               {
326                 /* FIXME: This doesn't work perfectly if a symmetric
327                    key comes before a public key in the message - if
328                    the user doesn't know the passphrase, then there is
329                    a chance that the "decrypted" algorithm will happen
330                    to be a valid one, which will make the returned dek
331                    appear valid, so we won't try any public keys that
332                    come later. */
333                 if(enc->seskeylen)
334                   {
335                     if(symkey_decrypt_seskey(c->dek, enc->seskey,
336                                              enc->seskeylen))
337                       {
338                         m_free(c->dek);
339                         c->dek=NULL;
340                       }
341                   }
342                 else
343                   c->dek->algo_info_printed = 1;
344               }
345           }
346       }
347
348  leave:
349     c->symkeys++;
350     free_packet(pkt);
351 }
352
353 static void
354 proc_pubkey_enc( CTX c, PACKET *pkt )
355 {
356     PKT_pubkey_enc *enc;
357     int result = 0;
358
359     /* check whether the secret key is available and store in this case */
360     c->last_was_session_key = 1;
361     enc = pkt->pkt.pubkey_enc;
362     /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
363     /* Hmmm: why do I have this algo check here - anyway there is
364      * function to check it. */
365     if( opt.verbose )
366         log_info(_("public key is %08lX\n"), (ulong)enc->keyid[1] );
367
368     if( is_status_enabled() ) {
369         char buf[50];
370         sprintf(buf, "%08lX%08lX %d 0",
371                 (ulong)enc->keyid[0], (ulong)enc->keyid[1], enc->pubkey_algo );
372         write_status_text( STATUS_ENC_TO, buf );
373     }
374
375     if( !opt.list_only && opt.override_session_key ) {
376         /* It does not make much sense to store the session key in
377          * secure memory because it has already been passed on the
378          * command line and the GCHQ knows about it */
379         c->dek = m_alloc_clear( sizeof *c->dek );
380         result = get_override_session_key ( c->dek, opt.override_session_key );
381         if ( result ) {
382             m_free(c->dek); c->dek = NULL;
383         }
384     }
385     else if( is_ELGAMAL(enc->pubkey_algo)
386         || enc->pubkey_algo == PUBKEY_ALGO_DSA
387         || is_RSA(enc->pubkey_algo)  ) {
388         if ( !c->dek && ((!enc->keyid[0] && !enc->keyid[1])
389                           || opt.try_all_secrets
390                           || !seckey_available( enc->keyid )) ) {
391             if( opt.list_only )
392                 result = -1;
393             else {
394                 c->dek = m_alloc_secure_clear( sizeof *c->dek );
395                 if( (result = get_session_key( enc, c->dek )) ) {
396                     /* error: delete the DEK */
397                     m_free(c->dek); c->dek = NULL;
398                 }
399             }
400         }
401         else
402             result = G10ERR_NO_SECKEY;
403     }
404     else
405         result = G10ERR_PUBKEY_ALGO;
406
407     if( result == -1 )
408         ;
409     else
410       {
411         /* store it for later display */
412         struct kidlist_item *x = m_alloc( sizeof *x );
413         x->kid[0] = enc->keyid[0];
414         x->kid[1] = enc->keyid[1];
415         x->pubkey_algo = enc->pubkey_algo;
416         x->reason = result;
417         x->next = c->pkenc_list;
418         c->pkenc_list = x;
419
420         if( !result && opt.verbose > 1 )
421           log_info( _("public key encrypted data: good DEK\n") );
422       }
423
424     free_packet(pkt);
425 }
426
427
428
429 /****************
430  * Print the list of public key encrypted packets which we could
431  * not decrypt.
432  */
433 static void
434 print_pkenc_list( struct kidlist_item *list, int failed )
435 {
436     for( ; list; list = list->next ) {
437         PKT_public_key *pk;
438         const char *algstr;
439         
440         if ( failed && !list->reason )
441             continue;
442         if ( !failed && list->reason )
443             continue;
444
445         algstr = pubkey_algo_to_string( list->pubkey_algo );
446         pk = m_alloc_clear( sizeof *pk );
447
448         if( !algstr )
449             algstr = "[?]";
450         pk->pubkey_algo = list->pubkey_algo;
451         if( !get_pubkey( pk, list->kid ) ) {
452             size_t n;
453             char *p;
454             log_info( _("encrypted with %u-bit %s key, ID %08lX, created %s\n"),
455                        nbits_from_pk( pk ), algstr, (ulong)list->kid[1],
456                        strtimestamp(pk->timestamp) );
457             fputs("      \"", log_stream() );
458             p = get_user_id( list->kid, &n );
459             print_utf8_string2 ( log_stream(), p, n, '"' );
460             m_free(p);
461             fputs("\"\n", log_stream() );
462         }
463         else {
464             log_info(_("encrypted with %s key, ID %08lX\n"),
465                         algstr, (ulong) list->kid[1] );
466         }
467         free_public_key( pk );
468
469         if( list->reason == G10ERR_NO_SECKEY ) {
470             if( is_status_enabled() ) {
471                 char buf[20];
472                 sprintf(buf,"%08lX%08lX", (ulong)list->kid[0],
473                                           (ulong)list->kid[1] );
474                 write_status_text( STATUS_NO_SECKEY, buf );
475             }
476         }
477         else if (list->reason)
478             log_info(_("public key decryption failed: %s\n"),
479                                                 g10_errstr(list->reason));
480     }
481 }
482
483
484 static void
485 proc_encrypted( CTX c, PACKET *pkt )
486 {
487     int result = 0;
488
489     if (!opt.quiet)
490       {
491         if(c->symkeys>1)
492           log_info(_("encrypted with %lu passphrases\n"),c->symkeys);
493         else if(c->symkeys==1)
494           log_info(_("encrypted with 1 passphrase\n"));
495         print_pkenc_list ( c->pkenc_list, 1 );
496         print_pkenc_list ( c->pkenc_list, 0 );
497       }
498
499     write_status( STATUS_BEGIN_DECRYPTION );
500
501     /*log_debug("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
502     if( opt.list_only )
503         result = -1;
504     else if( !c->dek && !c->last_was_session_key ) {
505         int algo;
506         STRING2KEY s2kbuf, *s2k = NULL;
507
508         if(opt.override_session_key)
509           {
510             c->dek = m_alloc_clear( sizeof *c->dek );
511             result=get_override_session_key(c->dek, opt.override_session_key);
512             if(result)
513               {
514                 m_free(c->dek);
515                 c->dek = NULL;
516               }
517           }
518         else
519           {
520             /* assume this is old style conventional encrypted data */
521             if ( (algo = opt.def_cipher_algo))
522               log_info (_("assuming %s encrypted data\n"),
523                         cipher_algo_to_string(algo));
524             else if ( check_cipher_algo(CIPHER_ALGO_IDEA) )
525               {
526                 algo = opt.def_cipher_algo;
527                 if (!algo)
528                   algo = opt.s2k_cipher_algo;
529                 idea_cipher_warn(1);
530                 log_info (_("IDEA cipher unavailable, "
531                             "optimistically attempting to use %s instead\n"),
532                           cipher_algo_to_string(algo));
533               }
534             else
535               {
536                 algo = CIPHER_ALGO_IDEA;
537                 if (!opt.s2k_digest_algo)
538                   {
539                     /* If no digest is given we assume MD5 */
540                     s2kbuf.mode = 0;
541                     s2kbuf.hash_algo = DIGEST_ALGO_MD5;
542                     s2k = &s2kbuf;
543                   }
544                 log_info (_("assuming %s encrypted data\n"), "IDEA");
545               }
546
547             c->dek = passphrase_to_dek ( NULL, 0, algo, s2k, 0, NULL, NULL );
548             if (c->dek)
549               c->dek->algo_info_printed = 1;
550           }
551     }
552     else if( !c->dek )
553         result = G10ERR_NO_SECKEY;
554     if( !result )
555         result = decrypt_data( c, pkt->pkt.encrypted, c->dek );
556
557     if( result == -1 )
558         ;
559     else if( !result || (result==G10ERR_BAD_SIGN && opt.ignore_mdc_error)) {
560         write_status( STATUS_DECRYPTION_OKAY );
561         if( opt.verbose > 1 )
562             log_info(_("decryption okay\n"));
563         if( pkt->pkt.encrypted->mdc_method && !result )
564             write_status( STATUS_GOODMDC );
565         else if(!opt.no_mdc_warn)
566             log_info (_("WARNING: message was not integrity protected\n"));
567         if(opt.show_session_key)
568           {
569             int i;
570             char *buf = m_alloc ( c->dek->keylen*2 + 20 );
571             sprintf ( buf, "%d:", c->dek->algo );
572             for(i=0; i < c->dek->keylen; i++ )
573               sprintf(buf+strlen(buf), "%02X", c->dek->key[i] );
574             log_info( "session key: \"%s\"\n", buf );
575             write_status_text ( STATUS_SESSION_KEY, buf );
576           }
577     }
578     else if( result == G10ERR_BAD_SIGN ) {
579         log_error(_("WARNING: encrypted message has been manipulated!\n"));
580         write_status( STATUS_BADMDC );
581         write_status( STATUS_DECRYPTION_FAILED );
582     }
583     else {
584         write_status( STATUS_DECRYPTION_FAILED );
585         log_error(_("decryption failed: %s\n"), g10_errstr(result));
586         /* Hmmm: does this work when we have encrypted using multiple
587          * ways to specify the session key (symmmetric and PK)*/
588     }
589     m_free(c->dek); c->dek = NULL;
590     free_packet(pkt);
591     c->last_was_session_key = 0;
592     write_status( STATUS_END_DECRYPTION );
593 }
594
595
596
597 static void
598 proc_plaintext( CTX c, PACKET *pkt )
599 {
600     PKT_plaintext *pt = pkt->pkt.plaintext;
601     int any, clearsig, only_md5, rc;
602     KBNODE n;
603
604     if( pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8 ) )
605         log_info(_("NOTE: sender requested \"for-your-eyes-only\"\n"));
606     else if( opt.verbose )
607         log_info(_("original file name='%.*s'\n"), pt->namelen, pt->name);
608     free_md_filter_context( &c->mfx );
609     c->mfx.md = md_open( 0, 0);
610     /* fixme: we may need to push the textfilter if we have sigclass 1
611      * and no armoring - Not yet tested
612      * Hmmm, why don't we need it at all if we have sigclass 1
613      * Should we assume that plaintext in mode 't' has always sigclass 1??
614      * See: Russ Allbery's mail 1999-02-09
615      */
616     any = clearsig = only_md5 = 0;
617     for(n=c->list; n; n = n->next ) {
618         if( n->pkt->pkttype == PKT_ONEPASS_SIG ) {
619             if( n->pkt->pkt.onepass_sig->digest_algo ) {
620                 md_enable( c->mfx.md, n->pkt->pkt.onepass_sig->digest_algo );
621                 if( !any && n->pkt->pkt.onepass_sig->digest_algo
622                                                       == DIGEST_ALGO_MD5 )
623                     only_md5 = 1;
624                 else
625                     only_md5 = 0;
626                 any = 1;
627             }
628             if( n->pkt->pkt.onepass_sig->sig_class != 0x01 )
629                 only_md5 = 0;
630         }
631         else if( n->pkt->pkttype == PKT_GPG_CONTROL
632                  && n->pkt->pkt.gpg_control->control
633                     == CTRLPKT_CLEARSIGN_START ) {
634             size_t datalen = n->pkt->pkt.gpg_control->datalen;
635             const byte *data = n->pkt->pkt.gpg_control->data;
636
637             /* check that we have at least the sigclass and one hash */
638             if ( datalen < 2 )
639                 log_fatal("invalid control packet CTRLPKT_CLEARSIGN_START\n"); 
640             /* Note that we don't set the clearsig flag for not-dash-escaped
641              * documents */
642             clearsig = (*data == 0x01);
643             for( data++, datalen--; datalen; datalen--, data++ )
644                 md_enable( c->mfx.md, *data );
645             any = 1;
646             break;  /* no pass signature pakets are expected */
647         }
648     }
649
650     if( !any && !opt.skip_verify ) {
651         /* no onepass sig packet: enable all standard algos */
652         md_enable( c->mfx.md, DIGEST_ALGO_RMD160 );
653         md_enable( c->mfx.md, DIGEST_ALGO_SHA1 );
654         md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
655     }
656     if( opt.pgp2_workarounds && only_md5 && !opt.skip_verify ) {
657         /* This is a kludge to work around a bug in pgp2.  It does only
658          * catch those mails which are armored.  To catch the non-armored
659          * pgp mails we could see whether there is the signature packet
660          * in front of the plaintext.  If someone needs this, send me a patch.
661          */
662         c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0);
663     }
664     if ( DBG_HASHING ) {
665         md_start_debug( c->mfx.md, "verify" );
666         if ( c->mfx.md2  )
667             md_start_debug( c->mfx.md2, "verify2" );
668     }
669     if ( c->pipemode.op == 'B' )
670         rc = handle_plaintext( pt, &c->mfx, 1, 0 );
671     else {
672         rc = handle_plaintext( pt, &c->mfx, c->sigs_only, clearsig );
673         if( rc == G10ERR_CREATE_FILE && !c->sigs_only) {
674             /* can't write output but we hash it anyway to
675              * check the signature */
676             rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
677         }
678     }
679     if( rc )
680         log_error( "handle plaintext failed: %s\n", g10_errstr(rc));
681     free_packet(pkt);
682     c->last_was_session_key = 0;
683
684     /* We add a marker control packet instead of the plaintext packet.
685      * This is so that we can later detect invalid packet sequences.
686      */
687     n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK, NULL, 0));
688     if (c->list)
689         add_kbnode (c->list, n);
690     else 
691         c->list = n;
692 }
693
694
695 static int
696 proc_compressed_cb( IOBUF a, void *info )
697 {
698     return proc_signature_packets( info, a, ((CTX)info)->signed_data,
699                                             ((CTX)info)->sigfilename );
700 }
701
702 static int
703 proc_encrypt_cb( IOBUF a, void *info )
704 {
705     return proc_encryption_packets( info, a );
706 }
707
708 static void
709 proc_compressed( CTX c, PACKET *pkt )
710 {
711     PKT_compressed *zd = pkt->pkt.compressed;
712     int rc;
713
714     /*printf("zip: compressed data packet\n");*/
715     if( c->sigs_only )
716         rc = handle_compressed( c, zd, proc_compressed_cb, c );
717     else if( c->encrypt_only )
718         rc = handle_compressed( c, zd, proc_encrypt_cb, c );
719     else
720         rc = handle_compressed( c, zd, NULL, NULL );
721     if( rc )
722         log_error("uncompressing failed: %s\n", g10_errstr(rc));
723     free_packet(pkt);
724     c->last_was_session_key = 0;
725 }
726
727 /****************
728  * check the signature
729  * Returns: 0 = valid signature or an error code
730  */
731 static int
732 do_check_sig( CTX c, KBNODE node, int *is_selfsig,
733               int *is_expkey, int *is_revkey )
734 {
735     PKT_signature *sig;
736     MD_HANDLE md = NULL, md2 = NULL;
737     int algo, rc;
738
739     assert( node->pkt->pkttype == PKT_SIGNATURE );
740     if( is_selfsig )
741         *is_selfsig = 0;
742     sig = node->pkt->pkt.signature;
743
744     algo = sig->digest_algo;
745     if( (rc=check_digest_algo(algo)) )
746         return rc;
747
748     if( sig->sig_class == 0x00 ) {
749         if( c->mfx.md )
750             md = md_copy( c->mfx.md );
751         else /* detached signature */
752             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
753     }
754     else if( sig->sig_class == 0x01 ) {
755         /* how do we know that we have to hash the (already hashed) text
756          * in canonical mode ??? (calculating both modes???) */
757         if( c->mfx.md ) {
758             md = md_copy( c->mfx.md );
759             if( c->mfx.md2 )
760                md2 = md_copy( c->mfx.md2 );
761         }
762         else { /* detached signature */
763           log_debug("Do we really need this here?");
764             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
765             md2 = md_open( 0, 0 );
766         }
767     }
768     else if( (sig->sig_class&~3) == 0x10
769              || sig->sig_class == 0x18
770              || sig->sig_class == 0x1f
771              || sig->sig_class == 0x20
772              || sig->sig_class == 0x28
773              || sig->sig_class == 0x30  ) { 
774         if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
775             || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
776             return check_key_signature( c->list, node, is_selfsig );
777         }
778         else if( sig->sig_class == 0x20 ) {
779             log_info(_("standalone revocation - "
780                        "use \"gpg --import\" to apply\n"));
781             return G10ERR_NOT_PROCESSED;
782         }
783         else {
784             log_error("invalid root packet for sigclass %02x\n",
785                                                         sig->sig_class);
786             return G10ERR_SIG_CLASS;
787         }
788     }
789     else
790         return G10ERR_SIG_CLASS;
791     rc = signature_check2( sig, md, NULL, is_expkey, is_revkey, NULL );
792     if( rc == G10ERR_BAD_SIGN && md2 )
793         rc = signature_check2( sig, md2, NULL, is_expkey, is_revkey, NULL );
794     md_close(md);
795     md_close(md2);
796
797     return rc;
798 }
799
800
801 static void
802 print_userid( PACKET *pkt )
803 {
804     if( !pkt )
805         BUG();
806     if( pkt->pkttype != PKT_USER_ID ) {
807         printf("ERROR: unexpected packet type %d", pkt->pkttype );
808         return;
809     }
810     if( opt.with_colons )
811       {
812         if(pkt->pkt.user_id->attrib_data)
813           printf("%u %lu",
814                  pkt->pkt.user_id->numattribs,
815                  pkt->pkt.user_id->attrib_len);
816         else
817           print_string( stdout,  pkt->pkt.user_id->name,
818                         pkt->pkt.user_id->len, ':');
819       }
820     else
821         print_utf8_string( stdout,  pkt->pkt.user_id->name,
822                                      pkt->pkt.user_id->len );
823 }
824
825
826 /****************
827  * List the certificate in a user friendly way
828  */
829
830 static void
831 list_node( CTX c, KBNODE node )
832 {
833     int any=0;
834     int mainkey;
835
836     if( !node )
837         ;
838     else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
839              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
840         PKT_public_key *pk = node->pkt->pkt.public_key;
841
842         if( opt.with_colons ) {
843             u32 keyid[2];
844             keyid_from_pk( pk, keyid );
845             if( mainkey )
846               c->trustletter = opt.fast_list_mode?
847                                            0 : get_validity_info( pk, NULL );
848             printf("%s:", mainkey? "pub":"sub" );
849             if( c->trustletter )
850                 putchar( c->trustletter );
851             printf(":%u:%d:%08lX%08lX:%s:%s::",
852                     nbits_from_pk( pk ),
853                     pk->pubkey_algo,
854                     (ulong)keyid[0],(ulong)keyid[1],
855                     colon_datestr_from_pk( pk ),
856                     colon_strtime (pk->expiredate) );
857             if( mainkey && !opt.fast_list_mode )
858                  putchar( get_ownertrust_info (pk) );
859             putchar(':');
860             if( node->next && node->next->pkt->pkttype == PKT_RING_TRUST) {
861                 putchar('\n'); any=1;
862                 if( opt.fingerprint )
863                     print_fingerprint( pk, NULL, 0 );
864                 printf("rtv:1:%u:\n",
865                             node->next->pkt->pkt.ring_trust->trustval );
866             }
867         }
868         else
869             printf("%s  %4u%c/%08lX %s%s",
870                                       mainkey? "pub":"sub",
871                                       nbits_from_pk( pk ),
872                                       pubkey_letter( pk->pubkey_algo ),
873                                       (ulong)keyid_from_pk( pk, NULL ),
874                                       datestr_from_pk( pk ),
875                                       mainkey?" ":"");
876
877         if( mainkey ) {
878             /* and now list all userids with their signatures */
879             for( node = node->next; node; node = node->next ) {
880                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
881                     if( !any ) {
882                         if( node->pkt->pkt.signature->sig_class == 0x20 )
883                             puts("[revoked]");
884                         else
885                             putchar('\n');
886                         any = 1;
887                     }
888                     list_node(c,  node );
889                 }
890                 else if( node->pkt->pkttype == PKT_USER_ID ) {
891                     if( any ) {
892                         if( opt.with_colons )
893                             printf("%s:::::::::",
894                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
895                         else
896                             printf( "uid%*s", 28, "" );
897                     }
898                     print_userid( node->pkt );
899                     if( opt.with_colons )
900                         putchar(':');
901                     putchar('\n');
902                     if( opt.fingerprint && !any )
903                         print_fingerprint( pk, NULL, 0 );
904                     if( node->next
905                         && node->next->pkt->pkttype == PKT_RING_TRUST ) {
906                         printf("rtv:2:%u:\n",
907                                  node->next->pkt->pkt.ring_trust->trustval );
908                     }
909                     any=1;
910                 }
911                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
912                     if( !any ) {
913                         putchar('\n');
914                         any = 1;
915                     }
916                     list_node(c,  node );
917                 }
918             }
919         }
920         else
921           {
922             /* of subkey */
923             if( pk->is_revoked )
924               printf(" %s",_("[revoked] "));
925             else if( pk->expiredate )
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.verbose )
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->trustletter = ' ';
1662     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1663         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1664         merge_keys_and_selfsig( node );
1665         list_node( c, node );
1666     }
1667     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1668         merge_keys_and_selfsig( node );
1669         list_node( c, node );
1670     }
1671     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1672         /* check all signatures */
1673         if( !c->have_data ) {
1674             free_md_filter_context( &c->mfx );
1675             /* prepare to create all requested message digests */
1676             c->mfx.md = md_open(0, 0);
1677
1678             /* fixme: why looking for the signature packet and not 1passpacket*/
1679             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1680                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1681             }
1682             /* ask for file and hash it */
1683             if( c->sigs_only ) {
1684                 rc = hash_datafiles( c->mfx.md, NULL,
1685                                      c->signed_data, c->sigfilename,
1686                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1687             }
1688             else {
1689                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1690                                                 iobuf_get_real_fname(c->iobuf),
1691                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1692             }
1693             if( rc ) {
1694                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1695                 return;
1696             }
1697         }
1698         else if ( c->signed_data ) {
1699             log_error (_("not a detached signature\n") );
1700             return;
1701         }
1702
1703         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1704             check_sig_and_print( c, n1 );
1705     }
1706     else if( node->pkt->pkttype == PKT_GPG_CONTROL
1707              && node->pkt->pkt.gpg_control->control
1708                 == CTRLPKT_CLEARSIGN_START ) {
1709         /* clear text signed message */
1710         if( !c->have_data ) {
1711             log_error("cleartext signature without data\n" );
1712             return;
1713         }
1714         else if ( c->signed_data ) {
1715             log_error (_("not a detached signature\n") );
1716             return;
1717         }
1718         
1719         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1720             check_sig_and_print( c, n1 );
1721     }
1722     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1723         PKT_signature *sig = node->pkt->pkt.signature;
1724         int multiple_ok=1;
1725
1726         n1=find_next_kbnode(node, PKT_SIGNATURE);
1727         if(n1)
1728           {
1729             byte class=sig->sig_class;
1730             byte hash=sig->digest_algo;
1731
1732             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
1733               {
1734                 /* We can't currently handle multiple signatures of
1735                    different classes or digests (we'd pretty much have
1736                    to run a different hash context for each), but if
1737                    they are all the same, make an exception. */
1738                 if(n1->pkt->pkt.signature->sig_class!=class
1739                    || n1->pkt->pkt.signature->digest_algo!=hash)
1740                   {
1741                     multiple_ok=0;
1742                     log_info(_("WARNING: multiple signatures detected.  "
1743                                "Only the first will be checked.\n"));
1744                     break;
1745                   }
1746               }
1747           }
1748
1749         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
1750             log_info(_("standalone signature of class 0x%02x\n"),
1751                                                     sig->sig_class);
1752         else if( !c->have_data ) {
1753             /* detached signature */
1754             free_md_filter_context( &c->mfx );
1755             c->mfx.md = md_open(sig->digest_algo, 0);
1756             if( !opt.pgp2_workarounds )
1757                 ;
1758             else if( sig->digest_algo == DIGEST_ALGO_MD5
1759                      && is_RSA( sig->pubkey_algo ) ) {
1760                 /* enable a workaround for a pgp2 bug */
1761                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
1762             }
1763             else if( sig->digest_algo == DIGEST_ALGO_SHA1
1764                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
1765                      && sig->sig_class == 0x01 ) {
1766                 /* enable the workaround also for pgp5 when the detached
1767                  * signature has been created in textmode */
1768                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
1769             }
1770 #if 0 /* workaround disabled */
1771             /* Here we have another hack to work around a pgp 2 bug
1772              * It works by not using the textmode for detached signatures;
1773              * this will let the first signature check (on md) fail
1774              * but the second one (on md2) which adds an extra CR should
1775              * then produce the "correct" hash.  This is very, very ugly
1776              * hack but it may help in some cases (and break others)
1777              */
1778                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
1779 #endif
1780             if ( DBG_HASHING ) {
1781                 md_start_debug( c->mfx.md, "verify" );
1782                 if ( c->mfx.md2  )
1783                     md_start_debug( c->mfx.md2, "verify2" );
1784             }
1785             if( c->sigs_only ) {
1786                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
1787                                      c->signed_data, c->sigfilename,
1788                                      (sig->sig_class == 0x01) );
1789             }
1790             else {
1791                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1792                                                 iobuf_get_real_fname(c->iobuf),
1793                                                 (sig->sig_class == 0x01) );
1794             }
1795             if( rc ) {
1796                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1797                 return;
1798             }
1799         }
1800         else if ( c->signed_data ) {
1801             log_error (_("not a detached signature\n") );
1802             return;
1803         }
1804         else if ( c->pipemode.op == 'B' )
1805             ; /* this is a detached signature trough the pipemode handler */
1806         else if (!opt.quiet)
1807             log_info(_("old style (PGP 2.x) signature\n"));
1808
1809         if(multiple_ok)
1810           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
1811             check_sig_and_print( c, n1 );
1812         else
1813           check_sig_and_print( c, node );
1814     }
1815     else {
1816         dump_kbnode (c->list);
1817         log_error(_("invalid root packet detected in proc_tree()\n"));
1818         dump_kbnode (node);
1819     }
1820 }