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