some cleanups
[gnupg.git] / g10 / sign.c
1 /* sign.c - sign data
2  *      Copyright (C) 1998 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 <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 #include "i18n.h"
39
40
41
42
43
44 static int
45 complete_sig( PKT_signature *sig, PKT_secret_cert *skc, MD_HANDLE md )
46 {
47     int rc=0;
48
49     if( (rc=check_secret_key( skc )) )
50         ;
51     else if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
52         g10_elg_sign( skc, sig, md, 0 );
53     else if( sig->pubkey_algo == PUBKEY_ALGO_DSA )
54         g10_dsa_sign( skc, sig, md, 0 );
55     else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
56         g10_rsa_sign( skc, sig, md, 0 );
57     else
58         BUG();
59
60     /* fixme: should we check wether the signature is okay? */
61
62     return rc;
63 }
64
65
66
67
68
69 /****************
70  * Sign the files whose names are in FILENAME.
71  * If DETACHED has the value true,
72  * make a detached signature.  If FILENAMES->d is NULL read from stdin
73  * and ignore the detached mode.  Sign the file with all secret keys
74  * which can be taken from LOCUSR, if this is NULL, use the default one
75  * If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
76  * signed data for these users.
77  * If OUTFILE is not NULL; this file is used for output and the function
78  * does not ask for overwrite permission; output is then always
79  * uncompressed, non-armored and in binary mode.
80  */
81 int
82 sign_file( STRLIST filenames, int detached, STRLIST locusr,
83            int encrypt, STRLIST remusr, const char *outfile )
84 {
85     const char *fname;
86     armor_filter_context_t afx;
87     compress_filter_context_t zfx;
88     md_filter_context_t mfx;
89     text_filter_context_t tfx;
90     encrypt_filter_context_t efx;
91     IOBUF inp = NULL, out = NULL;
92     PACKET pkt;
93     PKT_plaintext *pt = NULL;
94     u32 filesize;
95     int rc = 0;
96     PKC_LIST pkc_list = NULL;
97     SKC_LIST skc_list = NULL;
98     SKC_LIST skc_rover = NULL;
99     int multifile = 0;
100
101     memset( &afx, 0, sizeof afx);
102     memset( &zfx, 0, sizeof zfx);
103     memset( &mfx, 0, sizeof mfx);
104     memset( &tfx, 0, sizeof tfx);
105     memset( &efx, 0, sizeof efx);
106     init_packet( &pkt );
107
108     if( filenames ) {
109         fname = filenames->d;
110         multifile = !!filenames->next;
111     }
112     else
113         fname = NULL;
114
115     if( fname && filenames->next && (!detached || encrypt) )
116         log_bug("multiple files can only be detached signed");
117
118     if( (rc=build_skc_list( locusr, &skc_list, 1 )) )
119         goto leave;
120     if( encrypt ) {
121         if( (rc=build_pkc_list( remusr, &pkc_list )) )
122             goto leave;
123     }
124
125     /* prepare iobufs */
126     if( multifile )  /* have list of filenames */
127         inp = NULL; /* we do it later */
128     else if( !(inp = iobuf_open(fname)) ) {
129         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
130                                         strerror(errno) );
131         rc = G10ERR_OPEN_FILE;
132         goto leave;
133     }
134
135     if( outfile ) {
136         if( !(out = iobuf_create( outfile )) ) {
137             log_error("can't create %s: %s\n", outfile, strerror(errno) );
138             rc = G10ERR_CREATE_FILE;
139             goto leave;
140         }
141         else if( opt.verbose )
142             log_info("writing to '%s'\n", outfile );
143     }
144     else if( !(out = open_outfile( fname, opt.armor? 1: detached? 2:0 )) ) {
145         rc = G10ERR_CREATE_FILE;
146         goto leave;
147     }
148
149     /* prepare to calculate the MD over the input */
150     if( opt.textmode && !outfile )
151         iobuf_push_filter( inp, text_filter, &tfx );
152     mfx.md = md_open(DIGEST_ALGO_RMD160, 0);
153     if( !multifile )
154         iobuf_push_filter( inp, md_filter, &mfx );
155
156     if( opt.armor && !outfile  )
157         iobuf_push_filter( out, armor_filter, &afx );
158     write_comment( out, "#created by GNUPG v" VERSION " ("
159                                             PRINTABLE_OS_NAME ")");
160     if( opt.compress && !outfile )
161         iobuf_push_filter( out, compress_filter, &zfx );
162
163     if( encrypt ) {
164         efx.pkc_list = pkc_list;
165         /* fixme: set efx.cfx.datalen if known */
166         iobuf_push_filter( out, encrypt_filter, &efx );
167     }
168
169     if( !detached ) {
170         /* loop over the secret certificates and build headers */
171         for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
172             PKT_secret_cert *skc;
173             PKT_onepass_sig *ops;
174
175             skc = skc_rover->skc;
176             ops = m_alloc_clear( sizeof *ops );
177             ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
178             ops->digest_algo = DIGEST_ALGO_RMD160;
179             ops->pubkey_algo = skc->pubkey_algo;
180             keyid_from_skc( skc, ops->keyid );
181             ops->last = !skc_rover->next;
182
183             init_packet(&pkt);
184             pkt.pkttype = PKT_ONEPASS_SIG;
185             pkt.pkt.onepass_sig = ops;
186             rc = build_packet( out, &pkt );
187             free_packet( &pkt );
188             if( rc ) {
189                 log_error("build onepass_sig packet failed: %s\n",
190                                                         g10_errstr(rc));
191                 goto leave;
192             }
193         }
194     }
195
196
197     /* setup the inner packet */
198     if( detached ) {
199         if( multifile ) {
200             STRLIST sl;
201
202             if( opt.verbose )
203                 log_info("signing:" );
204             /* must walk reverse trough this list */
205             for( sl = strlist_last(filenames); sl;
206                         sl = strlist_prev( filenames, sl ) ) {
207                 if( !(inp = iobuf_open(sl->d)) ) {
208                     log_error("can't open %s: %s\n", sl->d, strerror(errno) );
209                     rc = G10ERR_OPEN_FILE;
210                     goto leave;
211                 }
212                 if( opt.verbose )
213                     fprintf(stderr, " '%s'", sl->d );
214                 iobuf_push_filter( inp, md_filter, &mfx );
215                 while( iobuf_get(inp) != -1 )
216                     ;
217                 iobuf_close(inp); inp = NULL;
218             }
219             if( opt.verbose )
220                 putc( '\n', stderr );
221         }
222         else {
223             /* read, so that the filter can calculate the digest */
224             while( iobuf_get(inp) != -1 )
225                 ;
226         }
227     }
228     else {
229         if( fname ) {
230             pt = m_alloc( sizeof *pt + strlen(fname) - 1 );
231             pt->namelen = strlen(fname);
232             memcpy(pt->name, fname, pt->namelen );
233             if( !(filesize = iobuf_get_filelength(inp)) )
234                 log_info("warning: '%s' is an empty file\n", fname );
235         }
236         else { /* no filename */
237             pt = m_alloc( sizeof *pt - 1 );
238             pt->namelen = 0;
239             filesize = 0; /* stdin */
240         }
241         pt->timestamp = make_timestamp();
242         pt->mode = opt.textmode && !outfile ? 't':'b';
243         pt->len = filesize;
244         pt->buf = inp;
245         pkt.pkttype = PKT_PLAINTEXT;
246         pkt.pkt.plaintext = pt;
247         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
248         if( (rc = build_packet( out, &pkt )) )
249             log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
250         pt->buf = NULL;
251     }
252
253     /* loop over the secret certificates */
254     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
255         PKT_secret_cert *skc;
256         PKT_signature *sig;
257         MD_HANDLE md;
258
259         skc = skc_rover->skc;
260
261         /* build the signature packet */
262         sig = m_alloc_clear( sizeof *sig );
263         sig->pubkey_algo = skc->pubkey_algo;
264         sig->timestamp = make_timestamp();
265         sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
266
267         md = md_copy( mfx.md );
268         md_putc( md, sig->sig_class );
269         {   u32 a = sig->timestamp;
270             md_putc( md, (a >> 24) & 0xff );
271             md_putc( md, (a >> 16) & 0xff );
272             md_putc( md, (a >>  8) & 0xff );
273             md_putc( md,  a        & 0xff );
274         }
275         md_final( md );
276
277         if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
278             g10_elg_sign( skc, sig, md, DIGEST_ALGO_RMD160 );
279         else if( sig->pubkey_algo == PUBKEY_ALGO_DSA )
280             g10_dsa_sign( skc, sig, md, DIGEST_ALGO_SHA1 );
281         else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
282             g10_rsa_sign( skc, sig, md, DIGEST_ALGO_RMD160 );
283         else
284             BUG();
285
286         md_close( md );
287
288         /* and write it */
289         init_packet(&pkt);
290         pkt.pkttype = PKT_SIGNATURE;
291         pkt.pkt.signature = sig;
292         rc = build_packet( out, &pkt );
293         free_packet( &pkt );
294         if( rc ) {
295             log_error("build signature packet failed: %s\n", g10_errstr(rc) );
296             goto leave;
297         }
298     }
299
300
301   leave:
302     if( rc )
303         iobuf_cancel(out);
304     else
305         iobuf_close(out);
306     iobuf_close(inp);
307     md_close( mfx.md );
308     release_skc_list( skc_list );
309     release_pkc_list( pkc_list );
310     return rc;
311 }
312
313
314
315 /****************
316  * note: we do not count empty lines at the beginning
317  */
318 static int
319 write_dash_escaped( IOBUF inp, IOBUF out, MD_HANDLE md )
320 {
321     int c;
322     int lastlf = 1;
323     int skip_empty = 1;
324
325     while( (c = iobuf_get(inp)) != -1 ) {
326         /* Note: We don't escape "From " because the MUA should cope with it */
327         if( lastlf ) {
328             if( c == '-' ) {
329                 iobuf_put( out, c );
330                 iobuf_put( out, ' ' );
331                 skip_empty = 0;
332             }
333             else if( skip_empty && c == '\r' )
334                 skip_empty = 2;
335             else
336                 skip_empty = 0;
337         }
338
339         if( !skip_empty )
340             md_putc(md, c );
341         iobuf_put( out, c );
342         lastlf = c == '\n';
343         if( skip_empty == 2 )
344             skip_empty = lastlf ? 0 : 1;
345     }
346     return 0; /* fixme: add error handling */
347 }
348
349
350 /****************
351  * make a clear signature. note that opt.armor is not needed
352  */
353 int
354 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
355 {
356     armor_filter_context_t afx;
357     compress_filter_context_t zfx;
358     text_filter_context_t tfx;
359     MD_HANDLE textmd = NULL;
360     IOBUF inp = NULL, out = NULL;
361     PACKET pkt;
362     int rc = 0;
363     SKC_LIST skc_list = NULL;
364     SKC_LIST skc_rover = NULL;
365
366     memset( &afx, 0, sizeof afx);
367     memset( &zfx, 0, sizeof zfx);
368     memset( &tfx, 0, sizeof tfx);
369     init_packet( &pkt );
370
371     if( (rc=build_skc_list( locusr, &skc_list, 1 )) )
372         goto leave;
373
374     /* prepare iobufs */
375     if( !(inp = iobuf_open(fname)) ) {
376         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
377                                         strerror(errno) );
378         rc = G10ERR_OPEN_FILE;
379         goto leave;
380     }
381
382     if( outfile ) {
383         if( !(out = iobuf_create( outfile )) ) {
384             log_error("can't create %s: %s\n", outfile, strerror(errno) );
385             rc = G10ERR_CREATE_FILE;
386             goto leave;
387         }
388         else if( opt.verbose )
389             log_info("writing to '%s'\n", outfile );
390     }
391     else if( !(out = open_outfile( fname, 1 )) ) {
392         rc = G10ERR_CREATE_FILE;
393         goto leave;
394     }
395
396     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n"
397                         "Hash: RIPEMD160\n\n" );
398
399     textmd = md_open(DIGEST_ALGO_RMD160, 0);
400     iobuf_push_filter( inp, text_filter, &tfx );
401     rc = write_dash_escaped( inp, out, textmd );
402     if( rc )
403         goto leave;
404
405     iobuf_writestr(out, "\n" );
406     afx.what = 2;
407     iobuf_push_filter( out, armor_filter, &afx );
408
409     /* loop over the secret certificates */
410     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
411         PKT_secret_cert *skc;
412         PKT_signature *sig;
413         MD_HANDLE md;
414
415         skc = skc_rover->skc;
416
417         /* build the signature packet */
418         sig = m_alloc_clear( sizeof *sig );
419         sig->pubkey_algo = skc->pubkey_algo;
420         sig->timestamp = make_timestamp();
421         sig->sig_class = 0x01;
422
423         md = md_copy( textmd );
424         md_putc( md, sig->sig_class );
425         {   u32 a = sig->timestamp;
426             md_putc( md, (a >> 24) & 0xff );
427             md_putc( md, (a >> 16) & 0xff );
428             md_putc( md, (a >>  8) & 0xff );
429             md_putc( md,  a        & 0xff );
430         }
431         md_final( md );
432
433         if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
434             g10_elg_sign( skc, sig, md, DIGEST_ALGO_RMD160 );
435         else if( sig->pubkey_algo == PUBKEY_ALGO_DSA )
436             g10_dsa_sign( skc, sig, md, DIGEST_ALGO_SHA1 );
437         else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
438             g10_rsa_sign( skc, sig, md, DIGEST_ALGO_RMD160 );
439         else
440             BUG();
441
442         md_close( md );
443
444         /* and write it */
445         init_packet(&pkt);
446         pkt.pkttype = PKT_SIGNATURE;
447         pkt.pkt.signature = sig;
448         rc = build_packet( out, &pkt );
449         free_packet( &pkt );
450         if( rc ) {
451             log_error("build signature packet failed: %s\n", g10_errstr(rc) );
452             goto leave;
453         }
454     }
455
456
457   leave:
458     if( rc )
459         iobuf_cancel(out);
460     else
461         iobuf_close(out);
462     iobuf_close(inp);
463     md_close( textmd );
464     release_skc_list( skc_list );
465     return rc;
466 }
467
468
469
470
471 static void
472 show_fingerprint( PKT_public_cert *pkc )
473 {
474     byte *array, *p;
475     size_t i, n;
476
477     p = array = fingerprint_from_pkc( pkc, &n );
478     tty_printf("             Fingerprint:");
479     if( n == 20 ) {
480         for(i=0; i < n ; i++, i++, p += 2 ) {
481             if( i == 10 )
482                 tty_printf(" ");
483             tty_printf(" %02X%02X", *p, p[1] );
484         }
485     }
486     else {
487         for(i=0; i < n ; i++, p++ ) {
488             if( i && !(i%8) )
489                 tty_printf(" ");
490             tty_printf(" %02X", *p );
491         }
492     }
493     tty_printf("\n");
494     m_free(array);
495 }
496
497
498 /****************
499  * Ask wether the user is willing to sign the key. Return true if so.
500  */
501 static int
502 sign_it_p( PKT_public_cert *pkc, PKT_user_id *uid )
503 {
504     char *answer;
505     int yes;
506
507     tty_printf("\nAre you really sure that you want so sign this key:\n\n"
508                "%4u%c/%08lX %s ",
509               nbits_from_pkc( pkc ),
510               pubkey_letter( pkc->pubkey_algo ),
511               (ulong)keyid_from_pkc( pkc, NULL ),
512               datestr_from_pkc( pkc )               );
513     tty_print_string( uid->name, uid->len );
514     tty_printf("\n");
515     show_fingerprint(pkc);
516     tty_printf("\n");
517     answer = tty_get("Sign this key? ");
518     tty_kill_prompt();
519     yes = answer_is_yes(answer);
520     m_free(answer);
521     return yes;
522 }
523
524
525 /****************
526  * Check the keysigs and set the flags to indicate errors.
527  * Usage of nodes flag bits:
528  * Bit  0 = bad signature
529  *      1 = no public key
530  *      2 = other error
531  * Returns true if error found.
532  */
533 static int
534 check_all_keysigs( KBNODE keyblock )
535 {
536     KBNODE kbctx;
537     KBNODE node;
538     int rc;
539     int inv_sigs = 0;
540     int no_key = 0;
541     int oth_err = 0;
542
543     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
544         if( node->pkt->pkttype == PKT_SIGNATURE
545             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
546             PKT_signature *sig = node->pkt->pkt.signature;
547             int sigrc;
548
549             tty_printf("sig");
550             switch( (rc = check_key_signature( keyblock, node,NULL)) ) {
551               case 0:                node->flag = 0; sigrc = '!'; break;
552               case G10ERR_BAD_SIGN:  inv_sigs++; node->flag = 1; sigrc = '-'; break;
553               case G10ERR_NO_PUBKEY: no_key++;   node->flag = 2; sigrc = '?'; break;
554               default:               oth_err++;  node->flag = 4; sigrc = '%'; break;
555             }
556             tty_printf("%c       %08lX %s   ",
557                     sigrc, sig->keyid[1], datestr_from_sig(sig));
558             if( sigrc == '%' )
559                 tty_printf("[%s] ", g10_errstr(rc) );
560             else if( sigrc == '?' )
561                 ;
562             else {
563                 size_t n;
564                 char *p = get_user_id( sig->keyid, &n );
565                 tty_print_string( p, n > 40? 40 : n );
566                 m_free(p);
567             }
568             tty_printf("\n");
569             /* FIXME: update the trustdb */
570         }
571     }
572     if( inv_sigs )
573         tty_printf("%d bad signatures\n", inv_sigs );
574     if( no_key )
575         tty_printf("No public key for %d signatures\n", no_key );
576     if( oth_err )
577         tty_printf("%d signatures not checked due to errors\n", oth_err );
578     return inv_sigs || no_key || oth_err;
579 }
580
581
582 /****************
583  * Ask and remove invalid signatures are to be removed.
584  */
585 static int
586 remove_keysigs( KBNODE keyblock, u32 *keyid, int all )
587 {
588     KBNODE kbctx;
589     KBNODE node;
590     char *answer;
591     int yes;
592     int count;
593
594     count = 0;
595     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
596         if( ((node->flag & 7) || all )
597             && node->pkt->pkttype == PKT_SIGNATURE
598             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
599             PKT_signature *sig = node->pkt->pkt.signature;
600
601             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
602                 /* fixme: skip self-sig */
603             }
604
605             tty_printf("\n \"%08lX %s   ",
606                         sig->keyid[1], datestr_from_sig(sig));
607             if( node->flag & 6 )
608                 tty_printf("[User name not available] ");
609             else {
610                 size_t n;
611                 char *p = get_user_id( sig->keyid, &n );
612                 tty_print_string( p, n );
613                 m_free(p);
614             }
615             tty_printf("\"\n");
616             if( node->flag & 1 )
617                 tty_printf("This is a BAD signature!\n");
618             else if( node->flag & 2 )
619                 tty_printf("Public key not available.\n");
620             else if( node->flag & 4 )
621                 tty_printf("The signature could not be checked!\n");
622
623             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
624                 continue; /* do not remove self-signatures */
625
626             answer = tty_get("\nRemove this signature? ");
627             tty_kill_prompt();
628             if( answer_is_yes(answer) ) {
629                 node->flag |= 128;     /* use bit 7 to mark this node */
630                 count++;
631             }
632             m_free(answer);
633         }
634     }
635
636     if( !count )
637         return 0; /* nothing to remove */
638     answer = tty_get("Do you really want to remove the selected signatures? ");
639     tty_kill_prompt();
640     yes = answer_is_yes(answer);
641     m_free(answer);
642     if( !yes )
643         return 0;
644
645     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 1)) ; ) {
646         if( node->flag & 128)
647             delete_kbnode(node );
648     }
649
650     return 1;
651 }
652
653
654 /****************
655  * This functions signs the key of USERNAME with all users listed in
656  * LOCUSR. If LOCUSR is NULL the default secret certificate will
657  * be used.  This works on all keyrings, so there is no armor or
658  * compress stuff here.
659  */
660 int
661 sign_key( const char *username, STRLIST locusr )
662 {
663     md_filter_context_t mfx;
664     int rc = 0;
665     SKC_LIST skc_list = NULL;
666     SKC_LIST skc_rover = NULL;
667     KBNODE keyblock = NULL;
668     KBNODE kbctx, node;
669     KBPOS kbpos;
670     PKT_public_cert *pkc;
671     u32 pkc_keyid[2];
672     char *answer;
673
674     memset( &mfx, 0, sizeof mfx);
675
676     /* search the userid */
677     rc = find_keyblock_byname( &kbpos, username );
678     if( rc ) {
679         log_error("user '%s' not found\n", username );
680         goto leave;
681     }
682
683     /* build a list of all signators */
684     rc=build_skc_list( locusr, &skc_list, 0 );
685     if( rc )
686         goto leave;
687
688
689     /* read the keyblock */
690     rc = read_keyblock( &kbpos, &keyblock );
691     if( rc ) {
692         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
693         goto leave;
694     }
695
696     /* get the keyid from the keyblock */
697     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
698     if( !node ) {
699         log_error("Oops; public key not found anymore!\n");
700         rc = G10ERR_GENERAL;
701         goto leave;
702     }
703
704     pkc = node->pkt->pkt.public_cert;
705     keyid_from_pkc( pkc, pkc_keyid );
706     log_info("Checking signatures of this public key certificate:\n");
707     tty_printf("pub  %4u%c/%08lX %s   ",
708               nbits_from_pkc( pkc ),
709               pubkey_letter( pkc->pubkey_algo ),
710               pkc_keyid[1], datestr_from_pkc(pkc) );
711     {
712         size_t n;
713         char *p = get_user_id( pkc_keyid, &n );
714         tty_print_string( p, n > 40? 40 : n );
715         m_free(p);
716         tty_printf("\n");
717     }
718
719     clear_kbnode_flags( keyblock );
720     if( check_all_keysigs( keyblock ) ) {
721         if( !opt.batch ) {
722             /* ask wether we really should do anything */
723             answer = tty_get("To you want to remove some of the invalid sigs? ");
724             tty_kill_prompt();
725             if( answer_is_yes(answer) )
726                 remove_keysigs( keyblock, pkc_keyid, 0 );
727             m_free(answer);
728         }
729     }
730
731     /* check wether we have already signed it */
732     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
733         u32 akeyid[2];
734
735         keyid_from_skc( skc_rover->skc, akeyid );
736         for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
737             if( node->pkt->pkttype == PKT_SIGNATURE
738                 && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
739                 if( akeyid[0] == node->pkt->pkt.signature->keyid[0]
740                     && akeyid[1] == node->pkt->pkt.signature->keyid[1] ) {
741                     log_info("Already signed by keyid %08lX\n",
742                                                         (ulong)akeyid[1] );
743                     skc_rover->mark = 1;
744                 }
745             }
746         }
747     }
748     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
749         if( !skc_rover->mark )
750             break;
751     }
752     if( !skc_rover ) {
753         log_info("Nothing to sign\n");
754         goto leave;
755     }
756
757     /* Loop over all signers and all user ids and sign */
758     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
759         if( skc_rover->mark )
760             continue;
761         for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
762             if( node->pkt->pkttype == PKT_USER_ID ) {
763                 if( sign_it_p( pkc, node->pkt->pkt.user_id ) ) {
764                     PACKET *pkt;
765                     PKT_signature *sig;
766
767                     rc = make_keysig_packet( &sig, pkc,
768                                                    node->pkt->pkt.user_id,
769                                                    skc_rover->skc,
770                                                    0x10,
771                                                    DIGEST_ALGO_RMD160 );
772                     if( rc ) {
773                         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc));
774                         goto leave;
775                     }
776
777                     pkt = m_alloc_clear( sizeof *pkt );
778                     pkt->pkttype = PKT_SIGNATURE;
779                     pkt->pkt.signature = sig;
780                     insert_kbnode( node, new_kbnode(pkt), PKT_USER_ID );
781                 }
782             }
783         }
784     }
785
786     rc = update_keyblock( &kbpos, keyblock );
787     if( rc ) {
788         log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
789         goto leave;
790     }
791
792   leave:
793     release_kbnode( keyblock );
794     release_skc_list( skc_list );
795     md_close( mfx.md );
796     return rc;
797 }
798
799
800
801 int
802 edit_keysigs( const char *username )
803 {
804     int rc = 0;
805     KBNODE keyblock = NULL;
806     KBNODE node;
807     KBPOS kbpos;
808     PKT_public_cert *pkc;
809     u32 pkc_keyid[2];
810
811     /* search the userid */
812     rc = find_keyblock_byname( &kbpos, username );
813     if( rc ) {
814         log_error("%s: user not found\n", username );
815         goto leave;
816     }
817
818     /* read the keyblock */
819     rc = read_keyblock( &kbpos, &keyblock );
820     if( rc ) {
821         log_error("%s: certificate read problem: %s\n", username, g10_errstr(rc) );
822         goto leave;
823     }
824
825     /* get the keyid from the keyblock */
826     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
827     if( !node ) {
828         log_error("Oops; public key not found anymore!\n");
829         rc = G10ERR_GENERAL;
830         goto leave;
831     }
832
833     pkc = node->pkt->pkt.public_cert;
834     keyid_from_pkc( pkc, pkc_keyid );
835     log_info("Checking signatures of this public key certificate:\n");
836     tty_printf("pub  %4u%c/%08lX %s   ",
837               nbits_from_pkc( pkc ),
838               pubkey_letter( pkc->pubkey_algo ),
839               pkc_keyid[1], datestr_from_pkc(pkc) );
840     {
841         size_t n;
842         char *p = get_user_id( pkc_keyid, &n );
843         tty_print_string( p, n > 40? 40 : n );
844         m_free(p);
845         tty_printf("\n");
846     }
847
848     clear_kbnode_flags( keyblock );
849     check_all_keysigs( keyblock );
850     if( remove_keysigs( keyblock, pkc_keyid, 1 ) ) {
851         rc = update_keyblock( &kbpos, keyblock );
852         if( rc ) {
853             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
854             goto leave;
855         }
856     }
857
858   leave:
859     release_kbnode( keyblock );
860     return rc;
861 }
862
863
864 /****************
865  * Delete a public or secret key from a keyring.
866  */
867 int
868 delete_key( const char *username, int secret )
869 {
870     int rc = 0;
871     KBNODE keyblock = NULL;
872     KBNODE node;
873     KBPOS kbpos;
874     PKT_public_cert *pkc = NULL;
875     PKT_secret_cert *skc = NULL;
876     u32 keyid[2];
877     int okay=0;
878
879     /* search the userid */
880     rc = secret? find_secret_keyblock_byname( &kbpos, username )
881                : find_keyblock_byname( &kbpos, username );
882     if( rc ) {
883         log_error("%s: user not found\n", username );
884         goto leave;
885     }
886
887     /* read the keyblock */
888     rc = read_keyblock( &kbpos, &keyblock );
889     if( rc ) {
890         log_error("%s: read problem: %s\n", username, g10_errstr(rc) );
891         goto leave;
892     }
893
894     /* get the keyid from the keyblock */
895     node = find_kbnode( keyblock, secret? PKT_SECRET_CERT:PKT_PUBLIC_CERT );
896     if( !node ) {
897         log_error("Oops; key not found anymore!\n");
898         rc = G10ERR_GENERAL;
899         goto leave;
900     }
901
902     if( secret ) {
903         skc = node->pkt->pkt.secret_cert;
904         keyid_from_skc( skc, keyid );
905     }
906     else {
907         pkc = node->pkt->pkt.public_cert;
908         keyid_from_pkc( pkc, keyid );
909         rc = seckey_available( keyid );
910         if( !rc ) {
911             log_error(_(
912             "there is a secret key for this public key!\n"));
913             log_info(_(
914             "use option \"--delete-secret-key\" to delete it first.\n"));
915             rc = -1;
916         }
917         else if( rc != G10ERR_NO_SECKEY )
918             log_error("%s: get secret key: %s\n", username, g10_errstr(rc) );
919         else
920             rc = 0;
921     }
922
923     if( rc )
924         rc = 0;
925     else if( opt.batch && secret )
926         log_error(_("can't do that in batch-mode\n"));
927     else if( opt.batch && opt.answer_yes )
928         okay++;
929     else if( opt.batch )
930         log_error(_("can't do that in batch-mode without \"--yes\"\n"));
931     else {
932         char *p;
933         size_t n;
934
935         if( secret )
936             tty_printf("sec  %4u%c/%08lX %s   ",
937                       nbits_from_skc( skc ),
938                       pubkey_letter( skc->pubkey_algo ),
939                       keyid[1], datestr_from_skc(skc) );
940         else
941             tty_printf("pub  %4u%c/%08lX %s   ",
942                       nbits_from_pkc( pkc ),
943                       pubkey_letter( pkc->pubkey_algo ),
944                       keyid[1], datestr_from_pkc(pkc) );
945         p = get_user_id( keyid, &n );
946         tty_print_string( p, n );
947         m_free(p);
948         tty_printf("\n\n");
949
950         p = tty_get(_("Delete this key from the keyring? "));
951         tty_kill_prompt();
952         if( secret && answer_is_yes(p)) {
953             /* I think it is not required to check a passphrase; if
954              * the user is so stupid to let others access his secret keyring
955              * (and has no backup) - it is up him to read some very
956              * basic texts about security.
957              */
958             m_free(p);
959             p = tty_get(_("This is a secret key! - really delete? "));
960         }
961         if( answer_is_yes(p) )
962             okay++;
963         m_free(p);
964     }
965
966
967     if( okay ) {
968         rc = delete_keyblock( &kbpos );
969         if( rc ) {
970             log_error("delete_keyblock failed: %s\n", g10_errstr(rc) );
971             goto leave;
972         }
973     }
974
975   leave:
976     release_kbnode( keyblock );
977     return rc;
978 }
979
980
981 int
982 change_passphrase( const char *username )
983 {
984     int rc = 0;
985     KBNODE keyblock = NULL;
986     KBNODE node;
987     KBPOS kbpos;
988     PKT_secret_cert *skc;
989     u32 skc_keyid[2];
990     char *answer;
991     int changed=0;
992
993     /* search the userid */
994     rc = find_secret_keyblock_byname( &kbpos, username );
995     if( rc ) {
996         log_error("secret key for user '%s' not found\n", username );
997         goto leave;
998     }
999
1000     /* read the keyblock */
1001     rc = read_keyblock( &kbpos, &keyblock );
1002     if( rc ) {
1003         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
1004         goto leave;
1005     }
1006
1007     /* get the keyid from the keyblock */
1008     node = find_kbnode( keyblock, PKT_SECRET_CERT );
1009     if( !node ) {
1010         log_error("Oops; secret key not found anymore!\n");
1011         rc = G10ERR_GENERAL;
1012         goto leave;
1013     }
1014
1015     skc = node->pkt->pkt.secret_cert;
1016     keyid_from_skc( skc, skc_keyid );
1017     tty_printf("sec  %4u%c/%08lX %s   ",
1018               nbits_from_skc( skc ),
1019               pubkey_letter( skc->pubkey_algo ),
1020               skc_keyid[1], datestr_from_skc(skc) );
1021     {
1022         size_t n;
1023         char *p = get_user_id( skc_keyid, &n );
1024         tty_print_string( p, n );
1025         m_free(p);
1026         tty_printf("\n");
1027     }
1028
1029     clear_kbnode_flags( keyblock );
1030     switch( is_secret_key_protected( skc ) ) {
1031       case -1:
1032         rc = G10ERR_PUBKEY_ALGO;
1033         break;
1034       case 0:
1035         tty_printf("This key is not protected.\n");
1036         break;
1037       default:
1038         tty_printf("Key is protected.\n");
1039         rc = check_secret_key( skc );
1040         break;
1041     }
1042
1043     if( rc )
1044         tty_printf("Can't edit this key: %s\n", g10_errstr(rc));
1045     else {
1046         DEK *dek = m_alloc_secure( sizeof *dek + 8 );
1047         byte *salt = (byte*)dek + sizeof( *dek );
1048
1049         tty_printf( "Enter the new passphrase for this secret key.\n\n" );
1050
1051         for(;;) {
1052             dek->algo = CIPHER_ALGO_BLOWFISH;
1053             randomize_buffer(salt, 8, 1);
1054             rc = make_dek_from_passphrase( dek , 2, salt );
1055             if( rc == -1 ) {
1056                 rc = 0;
1057                 tty_printf( "You don't want a passphrase -"
1058                             " this is probably a *bad* idea!\n\n");
1059                 answer = tty_get("Do you really want to do this? ");
1060                 tty_kill_prompt();
1061                 if( answer_is_yes(answer) )
1062                     changed++;
1063                 m_free(answer);
1064                 break;
1065             }
1066             else if( rc == G10ERR_PASSPHRASE ) {
1067                 tty_printf("passphrase not correctly repeated; try again.\n");
1068             }
1069             else if( rc ) {
1070                 m_free(dek); dek = NULL;
1071                 log_error("Error getting the passphrase: %s\n", g10_errstr(rc));
1072                 break;
1073             }
1074             else { /* okay */
1075                 /* FIXME: what about dsa */
1076                 skc->d.elg.protect.algo = CIPHER_ALGO_BLOWFISH;
1077                 skc->d.elg.protect.s2k  = 1;
1078                 skc->d.elg.protect.hash = DIGEST_ALGO_RMD160;
1079                 memcpy(skc->d.elg.protect.salt, salt, 8);
1080                 randomize_buffer(skc->d.elg.protect.iv, 8, 1);
1081                 rc = protect_secret_key( skc, dek );
1082                 if( rc )
1083                     log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
1084                 else
1085                     changed++;
1086                 break;
1087             }
1088         }
1089         m_free(dek);
1090     }
1091
1092
1093     if( changed ) {
1094         rc = update_keyblock( &kbpos, keyblock );
1095         if( rc ) {
1096             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
1097             goto leave;
1098         }
1099     }
1100
1101   leave:
1102     release_kbnode( keyblock );
1103     return rc;
1104 }
1105
1106
1107 /****************
1108  * Create a signature packet for the given public key certificate
1109  * and the user id and return it in ret_sig. User signature class SIGCLASS
1110  * user-id is not used (and may be NULL if sigclass is 0x20)
1111  */
1112 int
1113 make_keysig_packet( PKT_signature **ret_sig, PKT_public_cert *pkc,
1114                     PKT_user_id *uid, PKT_secret_cert *skc,
1115                     int sigclass, int digest_algo )
1116 {
1117     PKT_signature *sig;
1118     int rc=0;
1119     MD_HANDLE md;
1120
1121     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x20 );
1122     md = md_open( digest_algo, 0 );
1123
1124     /* hash the public key certificate and the user id */
1125     hash_public_cert( md, pkc );
1126     if( sigclass != 0x20 )
1127         md_write( md, uid->name, uid->len );
1128     /* and make the signature packet */
1129     sig = m_alloc_clear( sizeof *sig );
1130     sig->pubkey_algo = skc->pubkey_algo;
1131     sig->timestamp = make_timestamp();
1132     sig->sig_class = sigclass;
1133
1134     md_putc( md, sig->sig_class );
1135     {   u32 a = sig->timestamp;
1136         md_putc( md, (a >> 24) & 0xff );
1137         md_putc( md, (a >> 16) & 0xff );
1138         md_putc( md, (a >>  8) & 0xff );
1139         md_putc( md,  a        & 0xff );
1140     }
1141     md_final(md);
1142
1143     rc = complete_sig( sig, skc, md );
1144
1145     md_close( md );
1146     if( rc )
1147         free_seckey_enc( sig );
1148     else
1149         *ret_sig = sig;
1150     return rc;
1151 }
1152