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