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