a couple of changes; but some parts are now broken
[gnupg.git] / g10 / mainproc.c
1 /* mainproc.c - handle packets
2  *      Copyright (c) 1997 by Werner Koch (dd9jn)
3  *
4  * This file is part of G10.
5  *
6  * G10 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  * G10 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 <assert.h>
25
26 #include "packet.h"
27 #include "iobuf.h"
28 #include "memory.h"
29 #include "options.h"
30 #include "util.h"
31 #include "cipher.h"
32 #include "keydb.h"
33 #include "filter.h"
34 #include "cipher.h"
35 #include "main.h"
36 #include "status.h"
37
38
39 /****************
40  * Structure to hold the context
41  */
42
43 typedef struct {
44     PKT_public_cert *last_pubkey;
45     PKT_secret_cert *last_seckey;
46     PKT_user_id     *last_user_id;
47     md_filter_context_t mfx;
48     DEK *dek;
49     int last_was_pubkey_enc;
50     KBNODE cert;     /* the current certificate / or signature */
51     int have_data;
52     IOBUF iobuf;    /* used to get the filename etc. */
53 } *CTX;
54
55
56
57 static void list_node( CTX c, KBNODE node );
58 static void proc_tree( CTX c, KBNODE node );
59
60
61 static void
62 release_cert( CTX c )
63 {
64     if( !c->cert )
65         return;
66     proc_tree(c, c->cert );
67     release_kbnode( c->cert );
68     c->cert = NULL;
69 }
70
71
72 static int
73 add_onepass_sig( CTX c, PACKET *pkt )
74 {
75     KBNODE node;
76
77     if( c->cert ) { /* add another packet */
78         if( c->cert->pkt->pkttype != PKT_ONEPASS_SIG ) {
79            log_error("add_onepass_sig: another packet is in the way\n");
80            release_cert( c );
81         }
82         node = new_kbnode( pkt );
83         node->next = c->cert;
84         c->cert = node;
85     }
86     else /* insert the first one */
87         c->cert = node = new_kbnode( pkt );
88
89     return 1;
90 }
91
92
93 static int
94 add_public_cert( CTX c, PACKET *pkt )
95 {
96     release_cert( c );
97     c->cert = new_kbnode( pkt );
98     return 1;
99 }
100
101 static int
102 add_secret_cert( CTX c, PACKET *pkt )
103 {
104     release_cert( c );
105     c->cert = new_kbnode( pkt );
106     return 1;
107 }
108
109
110 static int
111 add_user_id( CTX c, PACKET *pkt )
112 {
113     KBNODE node, n1;
114
115     if( !c->cert ) {
116         log_error("orphaned user id\n" );
117         return 0;
118     }
119     /* goto the last certificate */
120     for(n1=c->cert; n1->next; n1 = n1->next )
121         ;
122     assert( n1->pkt );
123     if( n1->pkt->pkttype != PKT_PUBLIC_CERT
124         && n1->pkt->pkttype != PKT_SECRET_CERT ) {
125         log_error("invalid parent type %d for userid\n", n1->pkt->pkttype );
126         return 0;
127     }
128     /* add a new user id node at the end */
129     node = new_kbnode( pkt );
130     add_kbnode( n1, node );
131     return 1;
132 }
133
134
135 static int
136 add_signature( CTX c, PACKET *pkt )
137 {
138     KBNODE node, n1, n2;
139
140     if( pkt->pkttype == PKT_SIGNATURE && !c->cert ) {
141         /* This is the first signature for a following datafile.
142          * G10 does not write such packets, instead it always uses
143          * onepass-sig packets.  The drawback of PGP's method
144          * of prepending the signtaure to the data is,
145          * that it is not possible to make a signature from data read
146          * from stdin.  (Anyway, G10 is are able to read these stuff) */
147         node = new_kbnode( pkt );
148         c->cert = node;
149         return 1;
150     }
151     else if( !c->cert )
152         return 0; /* oops */
153     else if( !c->cert->pkt )
154         BUG();
155     else if( c->cert->pkt->pkttype == PKT_ONEPASS_SIG ) {
156         /* The root is a onepass signature, so we are signing data */
157         node = new_kbnode( pkt );
158         add_kbnode( c->cert, node );
159         return 1;
160     }
161
162     /* goto the last user id */
163     for(n2=NULL, n1=c->cert; n1->next; n1 = n1->next )
164         if( n1->pkt->pkttype == PKT_USER_ID )
165             n2 = n1;
166     if( !n2 ) {
167         log_error("no user id for signature packet\n");
168         return 0;
169     }
170     n1 = n2;
171     /* and add a new signature node id at the end */
172     node = new_kbnode( pkt );
173     insert_kbnode( n1, node, PKT_USER_ID );
174     return 1;
175 }
176
177
178 static void
179 proc_pubkey_enc( CTX c, PACKET *pkt )
180 {
181     PKT_pubkey_enc *enc;
182     int result = 0;
183
184     c->last_was_pubkey_enc = 1;
185     enc = pkt->pkt.pubkey_enc;
186     /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
187     if( enc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
188         || enc->pubkey_algo == PUBKEY_ALGO_RSA  ) {
189         m_free(c->dek ); /* paranoid: delete a pending DEK */
190         c->dek = m_alloc_secure( sizeof *c->dek );
191         if( (result = get_session_key( enc, c->dek )) ) {
192             /* error: delete the DEK */
193             m_free(c->dek); c->dek = NULL;
194         }
195     }
196     else
197         result = G10ERR_PUBKEY_ALGO;
198
199     if( result == -1 )
200         ;
201     else if( !result ) {
202         if( opt.verbose > 1 )
203             log_info( "pubkey_enc packet: Good DEK\n" );
204     }
205     else
206         log_error( "pubkey_enc packet: %s\n", g10_errstr(result));
207     free_packet(pkt);
208 }
209
210
211
212 static void
213 proc_encrypted( CTX c, PACKET *pkt )
214 {
215     int result = 0;
216
217     /*printf("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
218     if( !c->dek && !c->last_was_pubkey_enc ) {
219         /* assume this is conventional encrypted data */
220         c->dek = m_alloc_secure( sizeof *c->dek );
221         c->dek->algo = opt.def_cipher_algo;
222         result = make_dek_from_passphrase( c->dek, 0 );
223     }
224     else if( !c->dek )
225         result = G10ERR_NO_SECKEY;
226     if( !result )
227         result = decrypt_data( pkt->pkt.encrypted, c->dek );
228     m_free(c->dek); c->dek = NULL;
229     if( result == -1 )
230         ;
231     else if( !result ) {
232         if( opt.verbose > 1 )
233             log_info("encryption okay\n");
234     }
235     else {
236         log_error("encryption failed: %s\n", g10_errstr(result));
237     }
238     free_packet(pkt);
239     c->last_was_pubkey_enc = 0;
240 }
241
242
243 static void
244 proc_plaintext( CTX c, PACKET *pkt )
245 {
246     PKT_plaintext *pt = pkt->pkt.plaintext;
247     int rc;
248
249     if( opt.verbose )
250         log_info("original file name='%.*s'\n", pt->namelen, pt->name);
251     free_md_filter_context( &c->mfx );
252     /* fixme: take the digest algo(s) to use from the
253      * onepass_sig packet (if we have these)
254      * And look at the sigclass to check wether we should use the
255      * textmode filter (sigclass 0x01)
256      */
257     c->mfx.md = md_open( DIGEST_ALGO_RMD160, 0);
258     md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
259     rc = handle_plaintext( pt, &c->mfx );
260     if( rc )
261         log_error( "handle plaintext failed: %s\n", g10_errstr(rc));
262     free_packet(pkt);
263     c->last_was_pubkey_enc = 0;
264 }
265
266
267 static void
268 proc_compressed( CTX c, PACKET *pkt )
269 {
270     PKT_compressed *zd = pkt->pkt.compressed;
271     int rc;
272
273     /*printf("zip: compressed data packet\n");*/
274     rc = handle_compressed( zd );
275     if( rc )
276         log_error("uncompressing failed: %s\n", g10_errstr(rc));
277     free_packet(pkt);
278     c->last_was_pubkey_enc = 0;
279 }
280
281
282
283
284 /****************
285  * check the signature
286  * Returns: 0 = valid signature or an error code
287  */
288 static int
289 do_check_sig( CTX c, KBNODE node )
290 {
291     PKT_signature *sig;
292     MD_HANDLE md;
293     int algo, rc;
294
295     assert( node->pkt->pkttype == PKT_SIGNATURE );
296     sig = node->pkt->pkt.signature;
297
298     if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
299         algo = sig->d.elg.digest_algo;
300     else if(sig->pubkey_algo == PUBKEY_ALGO_RSA )
301         algo = sig->d.rsa.digest_algo;
302     else
303         return G10ERR_PUBKEY_ALGO;
304     if( (rc=check_digest_algo(algo)) )
305         return rc;
306
307     if( sig->sig_class == 0x00 ) {
308         md = md_copy( c->mfx.md );
309     }
310     else if( sig->sig_class == 0x01 ) {
311         /* how do we know that we have to hash the (already hashed) text
312          * in canonical mode ??? (calculating both modes???) */
313         md = md_copy( c->mfx.md );
314     }
315     else if( (sig->sig_class&~3) == 0x10 ) { /* classes 0x10 .. 0x13 */
316         if( c->cert->pkt->pkttype == PKT_PUBLIC_CERT ) {
317             KBNODE n1 = find_prev_kbnode( c->cert, node, PKT_USER_ID );
318
319             if( n1 ) {
320                 if( c->cert->pkt->pkt.public_cert->mfx.md )
321                     md = md_copy( c->cert->pkt->pkt.public_cert->mfx.md );
322                 else
323                     BUG();
324                 md_write( md, n1->pkt->pkt.user_id->name, n1->pkt->pkt.user_id->len);
325             }
326             else {
327                 log_error("invalid parent packet for sigclass 0x10\n");
328                 return G10ERR_SIG_CLASS;
329             }
330         }
331         else {
332             log_error("invalid root packet for sigclass 0x10\n");
333             return G10ERR_SIG_CLASS;
334         }
335     }
336     else
337         return G10ERR_SIG_CLASS;
338     rc = signature_check( sig, md );
339     md_close(md);
340
341     return rc;
342 }
343
344
345
346 static void
347 print_userid( PACKET *pkt )
348 {
349     if( !pkt )
350         BUG();
351     if( pkt->pkttype != PKT_USER_ID ) {
352         printf("ERROR: unexpected packet type %d", pkt->pkttype );
353         return;
354     }
355     print_string( stdout,  pkt->pkt.user_id->name, pkt->pkt.user_id->len );
356 }
357
358
359 static void
360 print_fingerprint( PKT_public_cert *pkc, PKT_secret_cert *skc )
361 {
362     byte *array, *p;
363     size_t i, n;
364
365     p = array = skc? fingerprint_from_skc( skc, &n )
366                    : fingerprint_from_pkc( pkc, &n );
367     printf("     Key fingerprint =");
368     if( n == 20 ) {
369         for(i=0; i < n ; i++, i++, p += 2 ) {
370             if( i == 10 )
371                 putchar(' ');
372             printf(" %02X%02X", *p, p[1] );
373         }
374     }
375     else {
376         for(i=0; i < n ; i++, p++ ) {
377             if( i && !(i%8) )
378                 putchar(' ');
379             printf(" %02X", *p );
380         }
381     }
382     putchar('\n');
383     m_free(array);
384 }
385
386
387 /****************
388  * List the certificate in a user friendly way
389  */
390
391 static void
392 list_node( CTX c, KBNODE node )
393 {
394     int any=0;
395
396     if( !node )
397         ;
398     else if( node->pkt->pkttype == PKT_PUBLIC_CERT ) {
399         PKT_public_cert *pkc = node->pkt->pkt.public_cert;
400
401         printf("pub  %4u%c/%08lX %s ", nbits_from_pkc( pkc ),
402                                       pubkey_letter( pkc->pubkey_algo ),
403                                       (ulong)keyid_from_pkc( pkc, NULL ),
404                                       datestr_from_pkc( pkc )     );
405         /* and now list all userids with their signatures */
406         while( (node = find_next_kbnode(node, PKT_USER_ID)) ) {
407             if( any )
408                 printf( "%*s", 31, "" );
409             print_userid( node->pkt );
410             putchar('\n');
411             if( opt.fingerprint && !any )
412                 print_fingerprint( pkc, NULL );
413             list_node(c,  node );
414             any=1;
415         }
416         if( !any )
417             printf("ERROR: no user id!\n");
418     }
419     else if( node->pkt->pkttype == PKT_SECRET_CERT ) {
420         PKT_secret_cert *skc = node->pkt->pkt.secret_cert;
421
422         printf("sec  %4u%c/%08lX %s ", nbits_from_skc( skc ),
423                                       pubkey_letter( skc->pubkey_algo ),
424                                       (ulong)keyid_from_skc( skc, NULL ),
425                                       datestr_from_skc( skc )     );
426         /* and now list all userids */
427         while( (node = find_next_kbnode(node, PKT_USER_ID)) ) {
428             print_userid( node->pkt );
429             putchar('\n');
430             if( opt.fingerprint && !any )
431                 print_fingerprint( NULL, skc );
432             any=1;
433         }
434         if( !any )
435             printf("ERROR: no user id!\n");
436     }
437     else if( node->pkt->pkttype == PKT_USER_ID ) {
438         /* list everything under this user id */
439         while( (node = find_next_kbnode(node, 0 )) )
440             list_node(c, node );
441     }
442     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
443         PKT_signature *sig = node->pkt->pkt.signature;
444         int rc2;
445         size_t n;
446         char *p;
447         int sigrc = ' ';
448
449         if( !opt.list_sigs )
450             return;
451
452         fputs("sig", stdout);
453         if( opt.check_sigs ) {
454             fflush(stdout);
455             switch( (rc2=do_check_sig( c, node )) ) {
456               case 0:                  sigrc = '!'; break;
457               case G10ERR_BAD_SIGN:    sigrc = '-'; break;
458               case G10ERR_NO_PUBKEY:   sigrc = '?'; break;
459               default:                 sigrc = '%'; break;
460             }
461         }
462         printf("%c       %08lX %s   ",
463                 sigrc, (ulong)sig->keyid[1], datestr_from_sig(sig));
464         if( sigrc == '%' )
465             printf("[%s] ", g10_errstr(rc2) );
466         else if( sigrc == '?' )
467             ;
468         else {
469             p = get_user_id( sig->keyid, &n );
470             print_string( stdout, p, n );
471             m_free(p);
472         }
473         putchar('\n');
474     }
475     else
476         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
477 }
478
479
480 int
481 proc_packets( IOBUF a )
482 {
483     CTX c = m_alloc_clear( sizeof *c );
484     PACKET *pkt = m_alloc( sizeof *pkt );
485     int rc;
486     int newpkt;
487
488     c->iobuf = a;
489     init_packet(pkt);
490     while( (rc=parse_packet(a, pkt)) != -1 ) {
491         /* cleanup if we have an illegal data structure */
492         if( c->dek && pkt->pkttype != PKT_ENCRYPTED ) {
493             log_error("oops: valid pubkey enc packet not followed by data\n");
494             m_free(c->dek); c->dek = NULL; /* burn it */
495         }
496
497         if( rc ) {
498             free_packet(pkt);
499             if( rc == G10ERR_INVALID_PACKET )
500                 break;
501             continue;
502         }
503         newpkt = -1;
504         if( opt.list_packets ) {
505             switch( pkt->pkttype ) {
506               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
507               case PKT_ENCRYPTED:   proc_encrypted( c, pkt ); break;
508               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
509               default: newpkt = 0; break;
510             }
511         }
512         else {
513             switch( pkt->pkttype ) {
514               case PKT_PUBLIC_CERT: newpkt = add_public_cert( c, pkt ); break;
515               case PKT_SECRET_CERT: newpkt = add_secret_cert( c, pkt ); break;
516               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
517               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
518               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
519               case PKT_ENCRYPTED:   proc_encrypted( c, pkt ); break;
520               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
521               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
522               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
523               default: newpkt = 0; break;
524             }
525         }
526         if( pkt->pkttype != PKT_SIGNATURE )
527             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
528
529         if( newpkt == -1 )
530             ;
531         else if( newpkt ) {
532             pkt = m_alloc( sizeof *pkt );
533             init_packet(pkt);
534         }
535         else
536             free_packet(pkt);
537     }
538
539     release_cert( c );
540     m_free(c->dek);
541     free_packet( pkt );
542     m_free( pkt );
543     free_md_filter_context( &c->mfx );
544     m_free( c );
545     return 0;
546 }
547
548
549 static void
550 print_keyid( FILE *fp, u32 *keyid )
551 {
552     size_t n;
553     char *p = get_user_id( keyid, &n );
554     print_string( fp, p, n );
555     m_free(p);
556 }
557
558
559
560 static int
561 check_sig_and_print( CTX c, KBNODE node )
562 {
563     PKT_signature *sig = node->pkt->pkt.signature;
564     int rc;
565
566     rc = do_check_sig(c, node );
567     if( !rc ) {
568         write_status( STATUS_GOODSIG );
569         log_info("Good signature from ");
570         print_keyid( stderr, sig->keyid );
571         putc('\n', stderr);
572     }
573     else if( rc == G10ERR_BAD_SIGN ) {
574         write_status( STATUS_BADSIG );
575         log_error("BAD signature from ");
576         print_keyid( stderr, sig->keyid );
577         putc('\n', stderr);
578         if( opt.batch )
579             g10_exit(1);
580     }
581     else {
582         write_status( STATUS_ERRSIG );
583         log_error("Can't check signature made by %08lX: %s\n",
584                    (ulong)sig->keyid[1], g10_errstr(rc) );
585     }
586     return rc;
587 }
588
589
590 /****************
591  * Process the tree which starts at node
592  */
593 static void
594 proc_tree( CTX c, KBNODE node )
595 {
596     KBNODE n1;
597     int rc;
598
599     if( opt.list_packets )
600         return;
601
602     if( node->pkt->pkttype == PKT_PUBLIC_CERT )
603         list_node( c, node );
604     else if( node->pkt->pkttype == PKT_SECRET_CERT )
605         list_node( c, node );
606     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
607         /* check all signatures */
608         if( !c->have_data ) {
609             free_md_filter_context( &c->mfx );
610             /* prepare to create all requested message digests */
611             c->mfx.md = md_open(0, 0);
612             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
613                 md_enable( c->mfx.md,
614                            digest_algo_from_sig(n1->pkt->pkt.signature));
615             }
616             /* ask for file and hash it */
617             rc = ask_for_detached_datafile( &c->mfx,
618                                             iobuf_get_fname(c->iobuf));
619             if( rc ) {
620                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
621                 return;
622             }
623         }
624
625         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
626             check_sig_and_print( c, n1 );
627     }
628     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
629         PKT_signature *sig = node->pkt->pkt.signature;
630
631         log_info("proc_tree: old style signature\n");
632         if( !c->have_data ) {
633             free_md_filter_context( &c->mfx );
634             c->mfx.md = md_open(digest_algo_from_sig(sig), 0);
635             rc = ask_for_detached_datafile( &c->mfx,
636                                             iobuf_get_fname(c->iobuf));
637             if( rc ) {
638                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
639                 return;
640             }
641         }
642
643         check_sig_and_print( c, node );
644     }
645     else
646         log_error("proc_tree: invalid root packet\n");
647
648 }
649
650
651