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