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