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