* g10.c (main, rm_group): Add --ungroup command to remove a particular
[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 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 ",
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
876         if( mainkey ) {
877             /* and now list all userids with their signatures */
878             for( node = node->next; node; node = node->next ) {
879                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
880                     if( !any ) {
881                         if( node->pkt->pkt.signature->sig_class == 0x20 )
882                             puts("[revoked]");
883                         else
884                             putchar('\n');
885                         any = 1;
886                     }
887                     list_node(c,  node );
888                 }
889                 else if( node->pkt->pkttype == PKT_USER_ID ) {
890                     if( any ) {
891                         if( opt.with_colons )
892                             printf("%s:::::::::",
893                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
894                         else
895                             printf( "uid%*s", 28, "" );
896                     }
897                     print_userid( node->pkt );
898                     if( opt.with_colons )
899                         putchar(':');
900                     putchar('\n');
901                     if( opt.fingerprint && !any )
902                         print_fingerprint( pk, NULL, 0 );
903                     if( node->next
904                         && node->next->pkt->pkttype == PKT_RING_TRUST ) {
905                         printf("rtv:2:%u:\n",
906                                  node->next->pkt->pkt.ring_trust->trustval );
907                     }
908                     any=1;
909                 }
910                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
911                     if( !any ) {
912                         putchar('\n');
913                         any = 1;
914                     }
915                     list_node(c,  node );
916                 }
917             }
918         }
919         else if( pk->expiredate ) { /* of subkey */
920             printf(_(" [expires: %s]"), expirestr_from_pk( pk ) );
921         }
922
923         if( !any )
924             putchar('\n');
925         if( !mainkey && opt.fingerprint > 1 )
926             print_fingerprint( pk, NULL, 0 );
927     }
928     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
929              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
930         PKT_secret_key *sk = node->pkt->pkt.secret_key;
931
932         if( opt.with_colons ) {
933             u32 keyid[2];
934             keyid_from_sk( sk, keyid );
935             printf("%s::%u:%d:%08lX%08lX:%s:%s:::",
936                     mainkey? "sec":"ssb",
937                     nbits_from_sk( sk ),
938                     sk->pubkey_algo,
939                     (ulong)keyid[0],(ulong)keyid[1],
940                     colon_datestr_from_sk( sk ),
941                     colon_strtime (sk->expiredate)
942                     /* fixme: add LID */ );
943         }
944         else
945             printf("%s  %4u%c/%08lX %s ",
946                                       mainkey? "sec":"ssb",
947                                       nbits_from_sk( sk ),
948                                       pubkey_letter( sk->pubkey_algo ),
949                                       (ulong)keyid_from_sk( sk, NULL ),
950                                       datestr_from_sk( sk )   );
951         if( mainkey ) {
952             /* and now list all userids with their signatures */
953             for( node = node->next; node; node = node->next ) {
954                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
955                     if( !any ) {
956                         if( node->pkt->pkt.signature->sig_class == 0x20 )
957                             puts("[revoked]");
958                         else
959                             putchar('\n');
960                         any = 1;
961                     }
962                     list_node(c,  node );
963                 }
964                 else if( node->pkt->pkttype == PKT_USER_ID ) {
965                     if( any ) {
966                         if( opt.with_colons )
967                             printf("%s:::::::::",
968                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
969                         else
970                             printf( "uid%*s", 28, "" );
971                     }
972                     print_userid( node->pkt );
973                     if( opt.with_colons )
974                         putchar(':');
975                     putchar('\n');
976                     if( opt.fingerprint && !any )
977                         print_fingerprint( NULL, sk, 0 );
978                     any=1;
979                 }
980                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
981                     if( !any ) {
982                         putchar('\n');
983                         any = 1;
984                     }
985                     list_node(c,  node );
986                 }
987             }
988         }
989         if( !any )
990             putchar('\n');
991         if( !mainkey && opt.fingerprint > 1 )
992             print_fingerprint( NULL, sk, 0 );
993     }
994     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
995         PKT_signature *sig = node->pkt->pkt.signature;
996         int is_selfsig = 0;
997         int rc2=0;
998         size_t n;
999         char *p;
1000         int sigrc = ' ';
1001
1002         if( !opt.verbose )
1003             return;
1004
1005         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
1006             fputs("rev", stdout);
1007         else
1008             fputs("sig", stdout);
1009         if( opt.check_sigs ) {
1010             fflush(stdout);
1011             switch( (rc2=do_check_sig( c, node, &is_selfsig, NULL, NULL )) ) {
1012               case 0:                  sigrc = '!'; break;
1013               case G10ERR_BAD_SIGN:    sigrc = '-'; break;
1014               case G10ERR_NO_PUBKEY: 
1015               case G10ERR_UNU_PUBKEY:  sigrc = '?'; break;
1016               default:                 sigrc = '%'; break;
1017             }
1018         }
1019         else {  /* check whether this is a self signature */
1020             u32 keyid[2];
1021
1022             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
1023                 || c->list->pkt->pkttype == PKT_SECRET_KEY ) {
1024                 if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
1025                     keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
1026                 else
1027                     keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
1028
1029                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
1030                     is_selfsig = 1;
1031             }
1032         }
1033         if( opt.with_colons ) {
1034             putchar(':');
1035             if( sigrc != ' ' )
1036                 putchar(sigrc);
1037             printf("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1038                    (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1039                    colon_datestr_from_sig(sig),
1040                    colon_expirestr_from_sig(sig));
1041
1042             if(sig->trust_depth || sig->trust_value)
1043               printf("%d %d",sig->trust_depth,sig->trust_value);
1044             printf(":");
1045
1046             if(sig->trust_regexp)
1047               print_string(stdout,sig->trust_regexp,
1048                            strlen(sig->trust_regexp),':');
1049             printf(":");
1050         }
1051         else
1052             printf("%c       %08lX %s   ",
1053                     sigrc, (ulong)sig->keyid[1], datestr_from_sig(sig));
1054         if( sigrc == '%' )
1055             printf("[%s] ", g10_errstr(rc2) );
1056         else if( sigrc == '?' )
1057             ;
1058         else if( is_selfsig ) {
1059             if( opt.with_colons )
1060                 putchar(':');
1061             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
1062             if( opt.with_colons )
1063                 putchar(':');
1064         }
1065         else if( !opt.fast_list_mode ) {
1066             p = get_user_id( sig->keyid, &n );
1067             print_string( stdout, p, n, opt.with_colons );
1068             m_free(p);
1069         }
1070         if( opt.with_colons )
1071             printf(":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1072         putchar('\n');
1073     }
1074     else
1075         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
1076 }
1077
1078
1079
1080 int
1081 proc_packets( void *anchor, IOBUF a )
1082 {
1083     int rc;
1084     CTX c = m_alloc_clear( sizeof *c );
1085
1086     c->anchor = anchor;
1087     rc = do_proc_packets( c, a );
1088     m_free( c );
1089     return rc;
1090 }
1091
1092
1093
1094 int
1095 proc_signature_packets( void *anchor, IOBUF a,
1096                         STRLIST signedfiles, const char *sigfilename )
1097 {
1098     CTX c = m_alloc_clear( sizeof *c );
1099     int rc;
1100
1101     c->anchor = anchor;
1102     c->sigs_only = 1;
1103     c->signed_data = signedfiles;
1104     c->sigfilename = sigfilename;
1105     rc = do_proc_packets( c, a );
1106     m_free( c );
1107     return rc;
1108 }
1109
1110 int
1111 proc_encryption_packets( void *anchor, IOBUF a )
1112 {
1113     CTX c = m_alloc_clear( sizeof *c );
1114     int rc;
1115
1116     c->anchor = anchor;
1117     c->encrypt_only = 1;
1118     rc = do_proc_packets( c, a );
1119     m_free( c );
1120     return rc;
1121 }
1122
1123
1124 int
1125 do_proc_packets( CTX c, IOBUF a )
1126 {
1127     PACKET *pkt = m_alloc( sizeof *pkt );
1128     int rc=0;
1129     int any_data=0;
1130     int newpkt;
1131
1132     c->iobuf = a;
1133     init_packet(pkt);
1134     while( (rc=parse_packet(a, pkt)) != -1 ) {
1135         any_data = 1;
1136         if( rc ) {
1137             free_packet(pkt);
1138             /* stop processing when an invalid packet has been encountered
1139              * but don't do so when we are doing a --list-packet. */
1140             if( rc == G10ERR_INVALID_PACKET && opt.list_packets != 2 )
1141                 break;
1142             continue;
1143         }
1144         newpkt = -1;
1145         if( opt.list_packets ) {
1146             switch( pkt->pkttype ) {
1147               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1148               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1149               case PKT_ENCRYPTED:
1150               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1151               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1152               default: newpkt = 0; break;
1153             }
1154         }
1155         else if( c->sigs_only ) {
1156             switch( pkt->pkttype ) {
1157               case PKT_PUBLIC_KEY:
1158               case PKT_SECRET_KEY:
1159               case PKT_USER_ID:
1160               case PKT_SYMKEY_ENC:
1161               case PKT_PUBKEY_ENC:
1162               case PKT_ENCRYPTED:
1163               case PKT_ENCRYPTED_MDC:
1164                 write_status_text( STATUS_UNEXPECTED, "0" );
1165                 rc = G10ERR_UNEXPECTED;
1166                 goto leave;
1167               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1168               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1169               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1170               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1171               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1172               default: newpkt = 0; break;
1173             }
1174         }
1175         else if( c->encrypt_only ) {
1176             switch( pkt->pkttype ) {
1177               case PKT_PUBLIC_KEY:
1178               case PKT_SECRET_KEY:
1179               case PKT_USER_ID:
1180                 write_status_text( STATUS_UNEXPECTED, "0" );
1181                 rc = G10ERR_UNEXPECTED;
1182                 goto leave;
1183               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1184               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1185               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1186               case PKT_ENCRYPTED:
1187               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1188               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1189               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1190               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1191               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1192               default: newpkt = 0; break;
1193             }
1194         }
1195         else {
1196             switch( pkt->pkttype ) {
1197               case PKT_PUBLIC_KEY:
1198               case PKT_SECRET_KEY:
1199                 release_list( c );
1200                 c->list = new_kbnode( pkt );
1201                 newpkt = 1;
1202                 break;
1203               case PKT_PUBLIC_SUBKEY:
1204               case PKT_SECRET_SUBKEY:
1205                 newpkt = add_subkey( c, pkt );
1206                 break;
1207               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
1208               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1209               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1210               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1211               case PKT_ENCRYPTED:
1212               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1213               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1214               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1215               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1216               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1217               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
1218               default: newpkt = 0; break;
1219             }
1220         }
1221         /* This is a very ugly construct and frankly, I don't remember why
1222          * I used it.  Adding the MDC check here is a hack.
1223          * The right solution is to initiate another context for encrypted
1224          * packet and not to reuse the current one ...  It works right
1225          * when there is a compression packet inbetween which adds just
1226          * an extra layer.
1227          * Hmmm: Rewrite this whole module here?? 
1228          */
1229         if( pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC )
1230             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
1231
1232         if( newpkt == -1 )
1233             ;
1234         else if( newpkt ) {
1235             pkt = m_alloc( sizeof *pkt );
1236             init_packet(pkt);
1237         }
1238         else
1239             free_packet(pkt);
1240         if ( c->pipemode.stop_now ) {
1241             /* we won't get an EOF in pipemode, so we have to 
1242              * break the loop here */ 
1243             rc = -1;
1244             break;
1245         }
1246     }
1247     if( rc == G10ERR_INVALID_PACKET )
1248         write_status_text( STATUS_NODATA, "3" );
1249     if( any_data )
1250         rc = 0;
1251     else if( rc == -1 )
1252         write_status_text( STATUS_NODATA, "2" );
1253
1254
1255   leave:
1256     release_list( c );
1257     m_free(c->dek);
1258     free_packet( pkt );
1259     m_free( pkt );
1260     free_md_filter_context( &c->mfx );
1261     return rc;
1262 }
1263
1264
1265 static int
1266 check_sig_and_print( CTX c, KBNODE node )
1267 {
1268     PKT_signature *sig = node->pkt->pkt.signature;
1269     const char *astr, *tstr;
1270     int rc, is_expkey=0, is_revkey=0;
1271
1272     if( opt.skip_verify ) {
1273         log_info(_("signature verification suppressed\n"));
1274         return 0;
1275     }
1276
1277     /* It is not in all cases possible to check multiple signatures:
1278      * PGP 2 (which is also allowed by OpenPGP), does use the packet
1279      * sequence: sig+data,  OpenPGP does use onepas+data=sig and GnuPG
1280      * sometimes uses (because I did'nt read the specs right) data+sig.
1281      * Because it is possible to create multiple signatures with
1282      * different packet sequence (e.g. data+sig and sig+data) it might
1283      * not be possible to get it right:  let's say we have:
1284      * data+sig, sig+data,sig+data and we have not yet encountered the last
1285      * data, we could also see this a one data with 2 signatures and then 
1286      * data+sig.
1287      * To protect against this we check that all signatures follow
1288      * without any intermediate packets.  Note, that we won't get this
1289      * error when we use onepass packets or cleartext signatures because
1290      * we reset the list every time
1291      *
1292      * FIXME: Now that we have these marker packets, we should create a 
1293      * real grammar and check against this.
1294      */
1295     {
1296         KBNODE n;
1297         int n_sig=0;
1298
1299         for (n=c->list; n; n=n->next ) {
1300             if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1301                 n_sig++;
1302         }
1303         if (n_sig > 1) { /* more than one signature - check sequence */
1304             int tmp, onepass;
1305
1306             for (tmp=onepass=0,n=c->list; n; n=n->next ) {
1307                 if (n->pkt->pkttype == PKT_ONEPASS_SIG) 
1308                     onepass++;
1309                 else if (n->pkt->pkttype == PKT_GPG_CONTROL
1310                          && n->pkt->pkt.gpg_control->control
1311                             == CTRLPKT_CLEARSIGN_START ) {
1312                     onepass++; /* handle the same way as a onepass */
1313                 }
1314                 else if ( (tmp && n->pkt->pkttype != PKT_SIGNATURE) ) {
1315                     log_error(_("can't handle these multiple signatures\n"));
1316                     return 0;
1317                 }
1318                 else if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1319                     tmp = 1;
1320                 else if (!tmp && !onepass 
1321                          && n->pkt->pkttype == PKT_GPG_CONTROL
1322                          && n->pkt->pkt.gpg_control->control
1323                             == CTRLPKT_PLAINTEXT_MARK ) {
1324                     /* plaintext before signatures but no one-pass packets*/
1325                     log_error(_("can't handle these multiple signatures\n"));
1326                     return 0;
1327                 }
1328             }
1329         }
1330     }
1331
1332     tstr = asctimestamp(sig->timestamp);
1333     astr = pubkey_algo_to_string( sig->pubkey_algo );
1334     if(opt.verify_options&VERIFY_SHOW_LONG_KEYIDS)
1335       {
1336         log_info(_("Signature made %.*s\n"),(int)strlen(tstr), tstr);
1337         log_info(_("               using %s key %08lX%08lX\n"),
1338                  astr? astr: "?",(ulong)sig->keyid[0],(ulong)sig->keyid[1] );
1339       }
1340     else
1341       log_info(_("Signature made %.*s using %s key ID %08lX\n"),
1342                (int)strlen(tstr), tstr, astr? astr: "?",
1343                (ulong)sig->keyid[1] );
1344
1345     rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1346     if( rc == G10ERR_NO_PUBKEY && opt.keyserver_scheme && opt.keyserver_options.auto_key_retrieve) {
1347         if( keyserver_import_keyid ( sig->keyid )==0 )
1348             rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1349     }
1350
1351     /* If the key still isn't found, try to inform the user where it
1352        can be found. */
1353
1354     if(rc==G10ERR_NO_PUBKEY && sig->flags.pref_ks)
1355       {
1356         const byte *p;
1357         int seq=0;
1358         size_t n;
1359
1360         while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1361           {
1362             /* According to my favorite copy editor, in English
1363                grammar, you say "at" if the key is located on a web
1364                page, but "from" if it is located on a keyserver.  I'm
1365                not going to even try to make two strings here :) */
1366             log_info(_("Key available at: ") );
1367             print_string( log_stream(), p, n, 0 );
1368             putc( '\n', log_stream() );
1369           }
1370       }
1371
1372     if( !rc || rc == G10ERR_BAD_SIGN ) {
1373         KBNODE un, keyblock;
1374         int count=0, statno;
1375         char keyid_str[50];
1376         PKT_public_key *pk=NULL;
1377
1378         if(rc)
1379           statno=STATUS_BADSIG;
1380         else if(sig->flags.expired)
1381           statno=STATUS_EXPSIG;
1382         else if(is_expkey)
1383           statno=STATUS_EXPKEYSIG;
1384         else if(is_revkey)
1385           statno=STATUS_REVKEYSIG;
1386         else
1387           statno=STATUS_GOODSIG;
1388
1389         keyblock = get_pubkeyblock( sig->keyid );
1390
1391         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1392                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1393
1394         /* find and print the primary user ID */
1395         for( un=keyblock; un; un = un->next ) {
1396             int valid;
1397             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1398               {
1399                 pk=un->pkt->pkt.public_key;
1400                 continue;
1401               }
1402             if( un->pkt->pkttype != PKT_USER_ID )
1403                 continue;
1404             if ( !un->pkt->pkt.user_id->created )
1405                 continue;
1406             if ( un->pkt->pkt.user_id->is_revoked )
1407                 continue;
1408             if ( un->pkt->pkt.user_id->is_expired )
1409                 continue;
1410             if ( !un->pkt->pkt.user_id->is_primary )
1411                 continue;
1412             /* We want the textual primary user ID here */
1413             if ( un->pkt->pkt.user_id->attrib_data )
1414                 continue;
1415
1416             assert(pk);
1417
1418             /* Get it before we print anything to avoid interrupting
1419                the output with the "please do a --check-trustdb"
1420                line. */
1421             valid=get_validity(pk,un->pkt->pkt.user_id);
1422
1423             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1424             write_status_text_and_buffer (statno, keyid_str,
1425                                           un->pkt->pkt.user_id->name,
1426                                           un->pkt->pkt.user_id->len, 
1427                                           -1 );
1428
1429             log_info(rc? _("BAD signature from \"")
1430                        : sig->flags.expired ? _("Expired signature from \"")
1431                        : _("Good signature from \""));
1432             print_utf8_string( log_stream(), un->pkt->pkt.user_id->name,
1433                                              un->pkt->pkt.user_id->len );
1434             if(opt.verify_options&VERIFY_SHOW_VALIDITY)
1435               fprintf(log_stream(),"\" [%s]\n",trust_value_to_string(valid));
1436             else
1437               fputs("\"\n", log_stream() );
1438             count++;
1439         }
1440         if( !count ) {  /* just in case that we have no valid textual
1441                            userid */
1442             /* Try for an invalid textual userid */
1443             for( un=keyblock; un; un = un->next ) {
1444                 if( un->pkt->pkttype == PKT_USER_ID &&
1445                     !un->pkt->pkt.user_id->attrib_data )
1446                     break;
1447             }
1448
1449             /* Try for any userid at all */
1450             if(!un) {
1451                 for( un=keyblock; un; un = un->next ) {
1452                     if( un->pkt->pkttype == PKT_USER_ID )
1453                         break;
1454                 }
1455             }
1456
1457             if (opt.trust_model==TM_ALWAYS || !un)
1458                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1459
1460             write_status_text_and_buffer (statno, keyid_str,
1461                                           un? un->pkt->pkt.user_id->name:"[?]",
1462                                           un? un->pkt->pkt.user_id->len:3, 
1463                                           -1 );
1464
1465             log_info(rc? _("BAD signature from \"")
1466                        : sig->flags.expired ? _("Expired signature from \"")
1467                        : _("Good signature from \""));
1468             if (opt.trust_model!=TM_ALWAYS && un) {
1469                 fputs(_("[uncertain]"), log_stream() );
1470                 putc(' ', log_stream() );
1471             }
1472             print_utf8_string( log_stream(),
1473                                un? un->pkt->pkt.user_id->name:"[?]",
1474                                un? un->pkt->pkt.user_id->len:3 );
1475             fputs("\"\n", log_stream() );
1476         }
1477
1478         /* If we have a good signature and already printed 
1479          * the primary user ID, print all the other user IDs */
1480         if ( count && !rc ) {
1481             for( un=keyblock; un; un = un->next ) {
1482                 if( un->pkt->pkttype != PKT_USER_ID )
1483                     continue;
1484                 if((un->pkt->pkt.user_id->is_revoked
1485                     || un->pkt->pkt.user_id->is_expired)
1486                    && !(opt.verify_options&VERIFY_SHOW_UNUSABLE_UIDS))
1487                   continue;
1488                 /* Only skip textual primaries */
1489                 if ( un->pkt->pkt.user_id->is_primary &&
1490                      !un->pkt->pkt.user_id->attrib_data )
1491                     continue;
1492
1493                 if(un->pkt->pkt.user_id->attrib_data)
1494                   {
1495                     dump_attribs(un->pkt->pkt.user_id,pk,NULL);
1496
1497                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1498                       show_photos(un->pkt->pkt.user_id->attribs,
1499                                   un->pkt->pkt.user_id->numattribs,pk,NULL);
1500                   }
1501
1502                 log_info(    _("                aka \""));
1503                 print_utf8_string( log_stream(), un->pkt->pkt.user_id->name,
1504                                                  un->pkt->pkt.user_id->len );
1505
1506                 if(opt.verify_options&VERIFY_SHOW_VALIDITY)
1507                   {
1508                     const char *valid;
1509                     if(un->pkt->pkt.user_id->is_revoked)
1510                       valid=_("revoked");
1511                     else if(un->pkt->pkt.user_id->is_expired)
1512                       valid=_("expired");
1513                     else
1514                       valid=trust_value_to_string(get_validity(pk,
1515                                                                un->pkt->
1516                                                                pkt.user_id));
1517                     fprintf(log_stream(),"\" [%s]\n",valid);
1518                   }
1519                 else
1520                   fputs("\"\n", log_stream() );
1521             }
1522         }
1523         release_kbnode( keyblock );
1524
1525         if( !rc )
1526           {
1527             if(opt.verify_options&VERIFY_SHOW_POLICY_URLS)
1528               show_policy_url(sig,0,1);
1529             else
1530               show_policy_url(sig,0,2);
1531
1532             if(opt.verify_options&VERIFY_SHOW_KEYSERVER_URLS)
1533               show_keyserver_url(sig,0,1);
1534             else
1535               show_keyserver_url(sig,0,2);
1536
1537             if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
1538               show_notation(sig,0,1);
1539             else
1540               show_notation(sig,0,2);
1541           }
1542
1543         if( !rc && is_status_enabled() ) {
1544             /* print a status response with the fingerprint */
1545             PKT_public_key *vpk = m_alloc_clear( sizeof *vpk );
1546
1547             if( !get_pubkey( vpk, sig->keyid ) ) {
1548                 byte array[MAX_FINGERPRINT_LEN], *p;
1549                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1550                 size_t i, n;
1551
1552                 bufp = buf;
1553                 fingerprint_from_pk( vpk, array, &n );
1554                 p = array;
1555                 for(i=0; i < n ; i++, p++, bufp += 2)
1556                     sprintf(bufp, "%02X", *p );
1557                 /* TODO: Replace the reserved '0' in the field below
1558                    with bits for status flags (policy url, notation,
1559                    etc.).  Remember to make the buffer larger to
1560                    match! */
1561                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1562                         strtimestamp( sig->timestamp ),
1563                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1564                         sig->version,sig->pubkey_algo,sig->digest_algo,
1565                         sig->sig_class);
1566                 bufp = bufp + strlen (bufp);
1567                 if (!vpk->is_primary) {
1568                    u32 akid[2];
1569  
1570                    akid[0] = vpk->main_keyid[0];
1571                    akid[1] = vpk->main_keyid[1];
1572                    free_public_key (vpk);
1573                    vpk = m_alloc_clear( sizeof *vpk );
1574                    if (get_pubkey (vpk, akid)) {
1575                      /* impossible error, we simply return a zeroed out fpr */
1576                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1577                      memset (array, 0, n);
1578                    }
1579                    else
1580                      fingerprint_from_pk( vpk, array, &n );
1581                 }
1582                 p = array;
1583                 for(i=0; i < n ; i++, p++, bufp += 2)
1584                     sprintf(bufp, "%02X", *p );
1585                 write_status_text( STATUS_VALIDSIG, buf );
1586             }
1587             free_public_key( vpk );
1588         }
1589
1590         if( !rc )
1591             rc = check_signatures_trust( sig );
1592
1593         if(sig->flags.expired)
1594           {
1595             log_info(_("Signature expired %s\n"),
1596                      asctimestamp(sig->expiredate));
1597             rc=G10ERR_GENERAL; /* need a better error here? */
1598           }
1599         else if(sig->expiredate)
1600           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
1601
1602         if(opt.verbose)
1603           log_info(_("%s signature, digest algorithm %s\n"),
1604                    sig->sig_class==0x00?_("binary"):
1605                    sig->sig_class==0x01?_("textmode"):_("unknown"),
1606                    digest_algo_to_string(sig->digest_algo));
1607
1608         if( rc )
1609             g10_errors_seen = 1;
1610         if( opt.batch && rc )
1611             g10_exit(1);
1612     }
1613     else {
1614         char buf[50];
1615         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1616                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1617                      sig->pubkey_algo, sig->digest_algo,
1618                      sig->sig_class, (ulong)sig->timestamp, rc );
1619         write_status_text( STATUS_ERRSIG, buf );
1620         if( rc == G10ERR_NO_PUBKEY ) {
1621             buf[16] = 0;
1622             write_status_text( STATUS_NO_PUBKEY, buf );
1623         }
1624         if( rc != G10ERR_NOT_PROCESSED )
1625             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1626     }
1627     return rc;
1628 }
1629
1630
1631 /****************
1632  * Process the tree which starts at node
1633  */
1634 static void
1635 proc_tree( CTX c, KBNODE node )
1636 {
1637     KBNODE n1;
1638     int rc;
1639
1640     if( opt.list_packets || opt.list_only )
1641         return;
1642
1643     /* we must skip our special plaintext marker packets here becuase
1644        they may be the root packet.  These packets are only used in
1645        addionla checks and skipping them here doesn't matter */
1646     while ( node
1647             && node->pkt->pkttype == PKT_GPG_CONTROL
1648             && node->pkt->pkt.gpg_control->control
1649                          == CTRLPKT_PLAINTEXT_MARK ) {
1650         node = node->next;
1651     }
1652     if (!node)
1653         return;
1654
1655     c->trustletter = ' ';
1656     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1657         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1658         merge_keys_and_selfsig( node );
1659         list_node( c, node );
1660     }
1661     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1662         merge_keys_and_selfsig( node );
1663         list_node( c, node );
1664     }
1665     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1666         /* check all signatures */
1667         if( !c->have_data ) {
1668             free_md_filter_context( &c->mfx );
1669             /* prepare to create all requested message digests */
1670             c->mfx.md = md_open(0, 0);
1671
1672             /* fixme: why looking for the signature packet and not 1passpacket*/
1673             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1674                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1675             }
1676             /* ask for file and hash it */
1677             if( c->sigs_only ) {
1678                 rc = hash_datafiles( c->mfx.md, NULL,
1679                                      c->signed_data, c->sigfilename,
1680                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1681             }
1682             else {
1683                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1684                                                 iobuf_get_real_fname(c->iobuf),
1685                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1686             }
1687             if( rc ) {
1688                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1689                 return;
1690             }
1691         }
1692         else if ( c->signed_data ) {
1693             log_error (_("not a detached signature\n") );
1694             return;
1695         }
1696
1697         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1698             check_sig_and_print( c, n1 );
1699     }
1700     else if( node->pkt->pkttype == PKT_GPG_CONTROL
1701              && node->pkt->pkt.gpg_control->control
1702                 == CTRLPKT_CLEARSIGN_START ) {
1703         /* clear text signed message */
1704         if( !c->have_data ) {
1705             log_error("cleartext signature without data\n" );
1706             return;
1707         }
1708         else if ( c->signed_data ) {
1709             log_error (_("not a detached signature\n") );
1710             return;
1711         }
1712         
1713         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1714             check_sig_and_print( c, n1 );
1715     }
1716     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1717         PKT_signature *sig = node->pkt->pkt.signature;
1718         int multiple_ok=1;
1719
1720         n1=find_next_kbnode(node, PKT_SIGNATURE);
1721         if(n1)
1722           {
1723             byte class=sig->sig_class;
1724             byte hash=sig->digest_algo;
1725
1726             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
1727               {
1728                 /* We can't currently handle multiple signatures of
1729                    different classes or digests (we'd pretty much have
1730                    to run a different hash context for each), but if
1731                    they are all the same, make an exception. */
1732                 if(n1->pkt->pkt.signature->sig_class!=class
1733                    || n1->pkt->pkt.signature->digest_algo!=hash)
1734                   {
1735                     multiple_ok=0;
1736                     log_info(_("WARNING: multiple signatures detected.  "
1737                                "Only the first will be checked.\n"));
1738                     break;
1739                   }
1740               }
1741           }
1742
1743         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
1744             log_info(_("standalone signature of class 0x%02x\n"),
1745                                                     sig->sig_class);
1746         else if( !c->have_data ) {
1747             /* detached signature */
1748             free_md_filter_context( &c->mfx );
1749             c->mfx.md = md_open(sig->digest_algo, 0);
1750             if( !opt.pgp2_workarounds )
1751                 ;
1752             else if( sig->digest_algo == DIGEST_ALGO_MD5
1753                      && is_RSA( sig->pubkey_algo ) ) {
1754                 /* enable a workaround for a pgp2 bug */
1755                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
1756             }
1757             else if( sig->digest_algo == DIGEST_ALGO_SHA1
1758                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
1759                      && sig->sig_class == 0x01 ) {
1760                 /* enable the workaround also for pgp5 when the detached
1761                  * signature has been created in textmode */
1762                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
1763             }
1764 #if 0 /* workaround disabled */
1765             /* Here we have another hack to work around a pgp 2 bug
1766              * It works by not using the textmode for detached signatures;
1767              * this will let the first signature check (on md) fail
1768              * but the second one (on md2) which adds an extra CR should
1769              * then produce the "correct" hash.  This is very, very ugly
1770              * hack but it may help in some cases (and break others)
1771              */
1772                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
1773 #endif
1774             if ( DBG_HASHING ) {
1775                 md_start_debug( c->mfx.md, "verify" );
1776                 if ( c->mfx.md2  )
1777                     md_start_debug( c->mfx.md2, "verify2" );
1778             }
1779             if( c->sigs_only ) {
1780                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
1781                                      c->signed_data, c->sigfilename,
1782                                      (sig->sig_class == 0x01) );
1783             }
1784             else {
1785                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1786                                                 iobuf_get_real_fname(c->iobuf),
1787                                                 (sig->sig_class == 0x01) );
1788             }
1789             if( rc ) {
1790                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1791                 return;
1792             }
1793         }
1794         else if ( c->signed_data ) {
1795             log_error (_("not a detached signature\n") );
1796             return;
1797         }
1798         else if ( c->pipemode.op == 'B' )
1799             ; /* this is a detached signature trough the pipemode handler */
1800         else if (!opt.quiet)
1801             log_info(_("old style (PGP 2.x) signature\n"));
1802
1803         if(multiple_ok)
1804           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
1805             check_sig_and_print( c, n1 );
1806         else
1807           check_sig_and_print( c, node );
1808     }
1809     else {
1810         dump_kbnode (c->list);
1811         log_error(_("invalid root packet detected in proc_tree()\n"));
1812         dump_kbnode (node);
1813     }
1814 }