Sylvester Version
[gnupg.git] / g10 / sign.c
1 /* sign.c - sign data
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 <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "iobuf.h"
32 #include "keydb.h"
33 #include "memory.h"
34 #include "util.h"
35 #include "main.h"
36 #include "filter.h"
37 #include "ttyio.h"
38
39
40
41
42
43 static int
44 complete_sig( PKT_signature *sig, PKT_secret_cert *skc, MD_HANDLE *md )
45 {
46     int rc=0;
47
48     if( (rc=check_secret_key( skc )) )
49         ;
50     else if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
51         g10_elg_sign( skc, sig, md );
52     else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
53         g10_rsa_sign( skc, sig, md );
54     else
55         log_bug(NULL);
56
57     /* fixme: should we check wether the signature is okay? */
58
59     return rc;
60 }
61
62
63
64
65
66 /****************
67  * Sign the file with name FILENAME.  If DETACHED has the value true,
68  * make a detached signature.  If FILENAME is NULL read from stdin
69  * and ignore the detached mode.  Sign the file with all secret keys
70  * which can be taken from LOCUSR, if this is NULL, use the default one
71  * If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
72  * signed data for these users.
73  */
74 int
75 sign_file( const char *filename, int detached, STRLIST locusr,
76            int encrypt, STRLIST remusr )
77 {
78     armor_filter_context_t afx;
79     compress_filter_context_t zfx;
80     md_filter_context_t mfx;
81     text_filter_context_t tfx;
82     IOBUF inp = NULL, out = NULL;
83     PACKET pkt;
84     PKT_plaintext *pt = NULL;
85     u32 filesize;
86     int last_rc, rc = 0;
87     PKC_LIST pkc_list = NULL;
88     SKC_LIST skc_list = NULL;
89     SKC_LIST skc_rover = NULL;
90
91     memset( &afx, 0, sizeof afx);
92     memset( &zfx, 0, sizeof zfx);
93     memset( &mfx, 0, sizeof mfx);
94     memset( &tfx, 0, sizeof tfx);
95     init_packet( &pkt );
96
97     if( (rc=build_skc_list( locusr, &skc_list, 1 )) )
98         goto leave;
99     if( encrypt ) {
100         if( (rc=build_pkc_list( remusr, &pkc_list )) )
101             goto leave;
102     }
103
104     /* prepare iobufs */
105     if( !(inp = iobuf_open(filename)) ) {
106         log_error("can't open %s: %s\n", filename? filename: "[stdin]",
107                                         strerror(errno) );
108         rc = G10ERR_OPEN_FILE;
109         goto leave;
110     }
111
112     if( !(out = open_outfile( filename, opt.armor? 1: detached? 2:0 )) ) {
113         rc = G10ERR_CREATE_FILE;
114         goto leave;
115     }
116
117     /* prepare to calculate the MD over the input */
118     if( opt.textmode && opt.armor )
119         iobuf_push_filter( inp, text_filter, &tfx );
120     mfx.rmd160 = rmd160_open(0);
121     iobuf_push_filter( inp, md_filter, &mfx );
122
123     if( opt.armor )
124         iobuf_push_filter( out, armor_filter, &afx );
125     write_comment( out, "#Created by G10 pre-release " VERSION );
126     if( opt.compress )
127         iobuf_push_filter( out, compress_filter, &zfx );
128
129     if( encrypt ) {
130         /* prepare for encryption */
131         /* FIXME!!!!!!! */
132     }
133
134     /* loop over the secret certificates and build headers */
135     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
136         PKT_secret_cert *skc;
137         PKT_onepass_sig *ops;
138
139         skc = skc_rover->skc;
140         ops = m_alloc_clear( sizeof *ops );
141         ops->sig_class = opt.textmode? 0x01 : 0x00;
142         ops->digest_algo = DIGEST_ALGO_RMD160;
143         ops->pubkey_algo = skc->pubkey_algo;
144         keyid_from_skc( skc, ops->keyid );
145         ops->last = !skc_rover->next;
146
147         init_packet(&pkt);
148         pkt.pkttype = PKT_ONEPASS_SIG;
149         pkt.pkt.onepass_sig = ops;
150         rc = build_packet( out, &pkt );
151         free_packet( &pkt );
152         if( rc ) {
153             log_error("build onepass_sig packet failed: %s\n", g10_errstr(rc));
154             goto leave;
155         }
156     }
157
158
159     /* setup the inner packet */
160     if( detached ) {
161         /* read, so that the filter can calculate the digest */
162         while( iobuf_get(inp) != -1 )
163             ;
164     }
165     else {
166         if( filename ) {
167             pt = m_alloc( sizeof *pt + strlen(filename) - 1 );
168             pt->namelen = strlen(filename);
169             memcpy(pt->name, filename, pt->namelen );
170             if( !(filesize = iobuf_get_filelength(inp)) )
171                 log_info("warning: '%s' is an empty file\n", filename );
172         }
173         else { /* no filename */
174             pt = m_alloc( sizeof *pt - 1 );
175             pt->namelen = 0;
176             filesize = 0; /* stdin */
177         }
178         pt->timestamp = make_timestamp();
179         pt->mode = opt.textmode? 't':'b';
180         pt->len = filesize;
181         pt->buf = inp;
182         pkt.pkttype = PKT_PLAINTEXT;
183         pkt.pkt.plaintext = pt;
184         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
185         if( (rc = build_packet( out, &pkt )) )
186             log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
187         pt->buf = NULL;
188     }
189
190     /* loop over the secret certificates */
191     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
192         PKT_secret_cert *skc;
193         PKT_signature *sig;
194         RMDHANDLE rmd;
195         byte *dp;
196
197         skc = skc_rover->skc;
198
199         /* build the signature packet */
200         sig = m_alloc_clear( sizeof *sig );
201         sig->pubkey_algo = skc->pubkey_algo;
202         sig->timestamp = make_timestamp();
203         sig->sig_class = opt.textmode? 0x01 : 0x00;
204
205         rmd = rmd160_copy( mfx.rmd160 );
206         rmd160_putchar( rmd, sig->sig_class );
207         {   u32 a = sig->timestamp;
208             rmd160_putchar( rmd, (a >> 24) & 0xff );
209             rmd160_putchar( rmd, (a >> 16) & 0xff );
210             rmd160_putchar( rmd, (a >>  8) & 0xff );
211             rmd160_putchar( rmd,  a        & 0xff );
212         }
213         dp = rmd160_final( rmd );
214
215         if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
216             ELG_secret_key skey;
217             MPI frame;
218
219             keyid_from_skc( skc, sig->keyid );
220             sig->d.elg.digest_algo = DIGEST_ALGO_RMD160;
221             sig->d.elg.digest_start[0] = dp[0];
222             sig->d.elg.digest_start[1] = dp[1];
223             sig->d.elg.a = mpi_alloc( mpi_get_nlimbs(skc->d.elg.p) );
224             sig->d.elg.b = mpi_alloc( mpi_get_nlimbs(skc->d.elg.p) );
225             frame = encode_rmd160_value( dp, 20, mpi_get_nbits(skc->d.elg.p) );
226             skey.p = skc->d.elg.p;
227             skey.g = skc->d.elg.g;
228             skey.y = skc->d.elg.y;
229             skey.x = skc->d.elg.x;
230             elg_sign( sig->d.elg.a, sig->d.elg.b, frame, &skey);
231             memset( &skey, 0, sizeof skey );
232             mpi_free(frame);
233             if( opt.verbose ) {
234                 char *ustr = get_user_id_string( sig->keyid );
235                 log_info("ELG signature from: %s\n", ustr );
236                 m_free(ustr);
237             }
238         }
239       #ifdef HAVE_RSA_CIPHER
240         else if( sig->pubkey_algo == PUBKEY_ALGO_RSA ) {
241             RSA_secret_key skey;
242
243             keyid_from_skc( skc, sig->keyid );
244             sig->d.rsa.digest_algo = DIGEST_ALGO_RMD160;
245             sig->d.rsa.digest_start[0] = dp[0];
246             sig->d.rsa.digest_start[1] = dp[1];
247             sig->d.rsa.rsa_integer = encode_rmd160_value( dp, 20,
248                                             mpi_get_nbits(skc->d.rsa.rsa_n) );
249             skey.e = skc->d.rsa.rsa_e;
250             skey.n = skc->d.rsa.rsa_n;
251             skey.p = skc->d.rsa.rsa_p;
252             skey.q = skc->d.rsa.rsa_q;
253             skey.d = skc->d.rsa.rsa_d;
254             skey.u = skc->d.rsa.rsa_u;
255             rsa_secret( sig->d.rsa.rsa_integer, sig->d.rsa.rsa_integer, &skey);
256             memset( &skey, 0, sizeof skey );
257             if( opt.verbose ) {
258                 char *ustr = get_user_id_string( sig->keyid );
259                 log_info("RSA signature from: %s\n", ustr );
260                 m_free(ustr);
261             }
262             /* fixme: should we check wether the signature is okay? */
263         }
264       #endif/*HAVE_RSA_CIPHER*/
265         else
266             log_bug(NULL);
267
268         rmd160_close( rmd );
269
270         /* and write it */
271         init_packet(&pkt);
272         pkt.pkttype = PKT_SIGNATURE;
273         pkt.pkt.signature = sig;
274         rc = build_packet( out, &pkt );
275         free_packet( &pkt );
276         if( rc ) {
277             log_error("build signature packet failed: %s\n", g10_errstr(rc) );
278             goto leave;
279         }
280     }
281
282
283   leave:
284     if( rc )
285         iobuf_cancel(out);
286     else
287         iobuf_close(out);
288     iobuf_close(inp);
289     rmd160_close( mfx.rmd160 );
290     release_skc_list( skc_list );
291     release_pkc_list( pkc_list );
292     return rc;
293 }
294
295
296
297 static void
298 show_fingerprint( PKT_public_cert *pkc )
299 {
300     byte *array, *p;
301     size_t i, n;
302
303     p = array = fingerprint_from_pkc( pkc, &n );
304     tty_printf("             Fingerprint:");
305     if( n == 20 ) {
306         for(i=0; i < n ; i++, i++, p += 2 ) {
307             if( i == 10 )
308                 tty_printf(" ");
309             tty_printf(" %02X%02X", *p, p[1] );
310         }
311     }
312     else {
313         for(i=0; i < n ; i++, p++ ) {
314             if( i && !(i%8) )
315                 tty_printf(" ");
316             tty_printf(" %02X", *p );
317         }
318     }
319     tty_printf("\n");
320     m_free(array);
321 }
322
323
324 /****************
325  * Ask wether the user is willing to sign the key. Return true if so.
326  */
327 static int
328 sign_it_p( PKT_public_cert *pkc, PKT_user_id *uid )
329 {
330     char *answer;
331     int yes;
332
333     tty_printf("\nAre you really sure that you want so sign this key:\n\n"
334                "%4u%c/%08lX %s ",
335               nbits_from_pkc( pkc ),
336               pubkey_letter( pkc->pubkey_algo ),
337               (ulong)keyid_from_pkc( pkc, NULL ),
338               datestr_from_pkc( pkc )               );
339     tty_print_string( uid->name, uid->len );
340     tty_printf("\n");
341     show_fingerprint(pkc);
342     tty_printf("\n");
343     answer = tty_get("Sign this key? ");
344     tty_kill_prompt();
345     yes = answer_is_yes(answer);
346     m_free(answer);
347     return yes;
348 }
349
350
351 static void
352 check_all_keysigs( KBNODE keyblock )
353 {
354     KBNODE kbctx;
355     KBNODE node;
356     int rc;
357     int inv_sigs = 0;
358     int no_key = 0;
359     int oth_err = 0;
360
361     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
362         if( node->pkt->pkttype == PKT_SIGNATURE
363             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
364             PKT_signature *sig = node->pkt->pkt.signature;
365             int sigrc;
366
367             tty_printf("sig");
368             switch( (rc = check_key_signature( keyblock, node )) ) {
369               case 0:                node->flag = 0; sigrc = '!'; break;
370               case G10ERR_BAD_SIGN:  inv_sigs++; node->flag = 1; sigrc = '-'; break;
371               case G10ERR_NO_PUBKEY: no_key++;   node->flag = 2; sigrc = '?'; break;
372               default:               oth_err++;  node->flag = 4; sigrc = '%'; break;
373             }
374             tty_printf("%c       %08lX %s   ",
375                     sigrc, sig->keyid[1], datestr_from_sig(sig));
376             if( sigrc == '%' )
377                 tty_printf("[%s] ", g10_errstr(rc) );
378             else if( sigrc == '?' )
379                 ;
380             else {
381                 size_t n;
382                 char *p = get_user_id( sig->keyid, &n );
383                 tty_print_string( p, n > 40? 40 : n );
384                 m_free(p);
385             }
386             tty_printf("\n");
387         }
388     }
389     if( inv_sigs )
390         tty_printf("%d bad signatures\n", inv_sigs );
391     if( no_key )
392         tty_printf("No public key for %d signatures\n", no_key );
393     if( oth_err )
394         tty_printf("%d signatures not checked due to errors\n", oth_err );
395 }
396
397
398 /****************
399  * This functions signs the key of USERNAME with all users listed in
400  * LOCUSR. If LOCUSR is NULL the default secret certificate will
401  * be used.  This works on all keyrings, so there is no armor or
402  * compress stuff here.
403  */
404 int
405 sign_key( const char *username, STRLIST locusr )
406 {
407     md_filter_context_t mfx;
408     int rc = 0;
409     SKC_LIST skc_list = NULL;
410     SKC_LIST skc_rover = NULL;
411     KBNODE keyblock = NULL;
412     KBNODE kbctx, node;
413     KBPOS kbpos;
414     PKT_public_cert *pkc;
415     int any;
416     u32 pkc_keyid[2];
417
418     memset( &mfx, 0, sizeof mfx);
419
420     /* search the userid */
421     rc = search_keyblock_byname( &kbpos, username );
422     if( rc ) {
423         log_error("user '%s' not found\n", username );
424         goto leave;
425     }
426
427     /* build a list of all signators */
428     rc=build_skc_list( locusr, &skc_list, 0 );
429     if( rc )
430         goto leave;
431
432
433     /* read the keyblock */
434     rc = read_keyblock( &kbpos, &keyblock );
435     if( rc ) {
436         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
437         goto leave;
438     }
439
440     /* get the keyid from the keyblock */
441     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
442         if( node->pkt->pkttype == PKT_PUBLIC_CERT )
443             break;
444     }
445     if( !node ) {
446         log_error("Oops; public key not found anymore!\n");
447         rc = G10ERR_GENERAL;
448         goto leave;
449     }
450
451     pkc = node->pkt->pkt.public_cert;
452     keyid_from_pkc( pkc, pkc_keyid );
453     log_info("Checking signatures of this public key certificate:\n");
454     tty_printf("pub  %4u%c/%08lX %s   ",
455               nbits_from_pkc( pkc ),
456               pubkey_letter( pkc->pubkey_algo ),
457               pkc_keyid[1], datestr_from_pkc(pkc) );
458     {
459         size_t n;
460         char *p = get_user_id( pkc_keyid, &n );
461         tty_print_string( p, n > 40? 40 : n );
462         m_free(p);
463         tty_printf("\n");
464     }
465
466     clear_kbnode_flags( keyblock );
467     check_all_keysigs( keyblock );
468     /* look wether we should ask to remove invalid keys */
469     /*+ FIXME: */
470
471     /* check wether we have already signed it */
472     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
473         u32 akeyid[2];
474
475         keyid_from_skc( skc_rover->skc, akeyid );
476         for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
477             if( node->pkt->pkttype == PKT_SIGNATURE
478                 && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
479                 if( akeyid[0] == node->pkt->pkt.signature->keyid[0]
480                     && akeyid[1] == node->pkt->pkt.signature->keyid[1] ) {
481                     log_info("Already signed by keyid %08lX\n", akeyid[1] );
482                     skc_rover->mark = 1;
483                 }
484             }
485         }
486     }
487     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
488         if( !skc_rover->mark )
489             break;
490     }
491     if( !skc_rover ) {
492         log_info("Nothing to sign\n");
493         goto leave;
494     }
495
496     /* Loop over all signers and all user ids and sign */
497     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
498         if( skc_rover->mark )
499             continue;
500         for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
501             if( node->pkt->pkttype == PKT_USER_ID ) {
502                 if( sign_it_p( pkc, node->pkt->pkt.user_id ) ) {
503                     PACKET *pkt;
504                     PKT_signature *sig;
505
506                     rc = make_keysig_packet( &sig, pkc,
507                                                    node->pkt->pkt.user_id,
508                                                    skc_rover->skc,
509                                                    0x10,
510                                                    DIGEST_ALGO_RMD160 );
511                     if( rc ) {
512                         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc));
513                         goto leave;
514                     }
515
516                     pkt = m_alloc_clear( sizeof *pkt );
517                     pkt->pkttype = PKT_SIGNATURE;
518                     pkt->pkt.signature = sig;
519                     add_kbnode_as_child( node, new_kbnode( pkt ) );
520                 }
521             }
522         }
523     }
524
525     rc = update_keyblock( &kbpos, keyblock );
526     if( rc ) {
527         log_error("insert_keyblock failed: %s\n", g10_errstr(rc) );
528         goto leave;
529     }
530
531   leave:
532     release_kbnode( keyblock );
533     release_skc_list( skc_list );
534     rmd160_close( mfx.rmd160 );
535     return rc;
536 }
537
538
539
540 /****************
541  * Create a signature packet for the given public key certificate
542  * and the user id and return it in ret_sig. User signature class SIGCLASS
543  */
544 int
545 make_keysig_packet( PKT_signature **ret_sig, PKT_public_cert *pkc,
546                     PKT_user_id *uid, PKT_secret_cert *skc,
547                     int sigclass, int digest_algo )
548 {
549     PKT_signature *sig;
550     int rc=0;
551     MD_HANDLE *md;
552
553     assert( sigclass >= 0x10 && sigclass <= 0x13 );
554     md = md_open( digest_algo, 0 );
555     /* hash the public key certificate */
556     hash_public_cert( md, pkc );
557     md_write( md, uid->name, uid->len );
558     /* and make the signature packet */
559     sig = m_alloc_clear( sizeof *sig );
560     sig->pubkey_algo = skc->pubkey_algo;
561     sig->timestamp = make_timestamp();
562     sig->sig_class = sigclass;
563
564     md_putchar( md, sig->sig_class );
565     {   u32 a = sig->timestamp;
566         md_putchar( md, (a >> 24) & 0xff );
567         md_putchar( md, (a >> 16) & 0xff );
568         md_putchar( md, (a >>  8) & 0xff );
569         md_putchar( md,  a        & 0xff );
570     }
571
572     rc = complete_sig( sig, skc, md );
573
574     md_close( md );
575     if( rc )
576         free_seckey_enc( sig );
577     else
578         *ret_sig = sig;
579     return rc;
580 }
581