Trust stuff works partly.
[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 );
52     else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
53         g10_rsa_sign( skc, sig, md );
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 && opt.armor && !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         byte *dp;
250
251         skc = skc_rover->skc;
252
253         /* build the signature packet */
254         sig = m_alloc_clear( sizeof *sig );
255         sig->pubkey_algo = skc->pubkey_algo;
256         sig->timestamp = make_timestamp();
257         sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
258
259         md = md_copy( mfx.md );
260         md_putc( md, sig->sig_class );
261         {   u32 a = sig->timestamp;
262             md_putc( md, (a >> 24) & 0xff );
263             md_putc( md, (a >> 16) & 0xff );
264             md_putc( md, (a >>  8) & 0xff );
265             md_putc( md,  a        & 0xff );
266         }
267         md_final( md );
268         dp = md_read( md, DIGEST_ALGO_RMD160 );
269
270         if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
271             ELG_secret_key skey;
272             MPI frame;
273
274             keyid_from_skc( skc, sig->keyid );
275             sig->d.elg.digest_algo = DIGEST_ALGO_RMD160;
276             sig->d.elg.digest_start[0] = dp[0];
277             sig->d.elg.digest_start[1] = dp[1];
278             sig->d.elg.a = mpi_alloc( mpi_get_nlimbs(skc->d.elg.p) );
279             sig->d.elg.b = mpi_alloc( mpi_get_nlimbs(skc->d.elg.p) );
280             frame = encode_rmd160_value( dp, 20, mpi_get_nbits(skc->d.elg.p) );
281             skey.p = skc->d.elg.p;
282             skey.g = skc->d.elg.g;
283             skey.y = skc->d.elg.y;
284             skey.x = skc->d.elg.x;
285             elg_sign( sig->d.elg.a, sig->d.elg.b, frame, &skey);
286             memset( &skey, 0, sizeof skey );
287             mpi_free(frame);
288             if( opt.verbose ) {
289                 char *ustr = get_user_id_string( sig->keyid );
290                 log_info("ELG signature from: %s\n", ustr );
291                 m_free(ustr);
292             }
293         }
294       #ifdef HAVE_RSA_CIPHER
295         else if( sig->pubkey_algo == PUBKEY_ALGO_RSA ) {
296             RSA_secret_key skey;
297
298             keyid_from_skc( skc, sig->keyid );
299             sig->d.rsa.digest_algo = DIGEST_ALGO_RMD160;
300             sig->d.rsa.digest_start[0] = dp[0];
301             sig->d.rsa.digest_start[1] = dp[1];
302             sig->d.rsa.rsa_integer = encode_rmd160_value( dp, 20,
303                                             mpi_get_nbits(skc->d.rsa.rsa_n) );
304             skey.e = skc->d.rsa.rsa_e;
305             skey.n = skc->d.rsa.rsa_n;
306             skey.p = skc->d.rsa.rsa_p;
307             skey.q = skc->d.rsa.rsa_q;
308             skey.d = skc->d.rsa.rsa_d;
309             skey.u = skc->d.rsa.rsa_u;
310             rsa_secret( sig->d.rsa.rsa_integer, sig->d.rsa.rsa_integer, &skey);
311             memset( &skey, 0, sizeof skey );
312             if( opt.verbose ) {
313                 char *ustr = get_user_id_string( sig->keyid );
314                 log_info("RSA signature from: %s\n", ustr );
315                 m_free(ustr);
316             }
317             /* fixme: should we check wether the signature is okay? */
318         }
319       #endif/*HAVE_RSA_CIPHER*/
320         else
321             BUG();
322
323         md_close( md );
324
325         /* and write it */
326         init_packet(&pkt);
327         pkt.pkttype = PKT_SIGNATURE;
328         pkt.pkt.signature = sig;
329         rc = build_packet( out, &pkt );
330         free_packet( &pkt );
331         if( rc ) {
332             log_error("build signature packet failed: %s\n", g10_errstr(rc) );
333             goto leave;
334         }
335     }
336
337
338   leave:
339     if( rc )
340         iobuf_cancel(out);
341     else
342         iobuf_close(out);
343     iobuf_close(inp);
344     md_close( mfx.md );
345     release_skc_list( skc_list );
346     release_pkc_list( pkc_list );
347     return rc;
348 }
349
350
351
352 static void
353 show_fingerprint( PKT_public_cert *pkc )
354 {
355     byte *array, *p;
356     size_t i, n;
357
358     p = array = fingerprint_from_pkc( pkc, &n );
359     tty_printf("             Fingerprint:");
360     if( n == 20 ) {
361         for(i=0; i < n ; i++, i++, p += 2 ) {
362             if( i == 10 )
363                 tty_printf(" ");
364             tty_printf(" %02X%02X", *p, p[1] );
365         }
366     }
367     else {
368         for(i=0; i < n ; i++, p++ ) {
369             if( i && !(i%8) )
370                 tty_printf(" ");
371             tty_printf(" %02X", *p );
372         }
373     }
374     tty_printf("\n");
375     m_free(array);
376 }
377
378
379 /****************
380  * Ask wether the user is willing to sign the key. Return true if so.
381  */
382 static int
383 sign_it_p( PKT_public_cert *pkc, PKT_user_id *uid )
384 {
385     char *answer;
386     int yes;
387
388     tty_printf("\nAre you really sure that you want so sign this key:\n\n"
389                "%4u%c/%08lX %s ",
390               nbits_from_pkc( pkc ),
391               pubkey_letter( pkc->pubkey_algo ),
392               (ulong)keyid_from_pkc( pkc, NULL ),
393               datestr_from_pkc( pkc )               );
394     tty_print_string( uid->name, uid->len );
395     tty_printf("\n");
396     show_fingerprint(pkc);
397     tty_printf("\n");
398     answer = tty_get("Sign this key? ");
399     tty_kill_prompt();
400     yes = answer_is_yes(answer);
401     m_free(answer);
402     return yes;
403 }
404
405
406 /****************
407  * Check the keysigs and set the flags to indicate errors.
408  * Usage of nodes flag bits:
409  * Bit  0 = bad signature
410  *      1 = no public key
411  *      2 = other error
412  * Returns true if error found.
413  */
414 static int
415 check_all_keysigs( KBNODE keyblock )
416 {
417     KBNODE kbctx;
418     KBNODE node;
419     int rc;
420     int inv_sigs = 0;
421     int no_key = 0;
422     int oth_err = 0;
423
424     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
425         if( node->pkt->pkttype == PKT_SIGNATURE
426             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
427             PKT_signature *sig = node->pkt->pkt.signature;
428             int sigrc;
429
430             tty_printf("sig");
431             switch( (rc = check_key_signature( keyblock, node,NULL)) ) {
432               case 0:                node->flag = 0; sigrc = '!'; break;
433               case G10ERR_BAD_SIGN:  inv_sigs++; node->flag = 1; sigrc = '-'; break;
434               case G10ERR_NO_PUBKEY: no_key++;   node->flag = 2; sigrc = '?'; break;
435               default:               oth_err++;  node->flag = 4; sigrc = '%'; break;
436             }
437             tty_printf("%c       %08lX %s   ",
438                     sigrc, sig->keyid[1], datestr_from_sig(sig));
439             if( sigrc == '%' )
440                 tty_printf("[%s] ", g10_errstr(rc) );
441             else if( sigrc == '?' )
442                 ;
443             else {
444                 size_t n;
445                 char *p = get_user_id( sig->keyid, &n );
446                 tty_print_string( p, n > 40? 40 : n );
447                 m_free(p);
448             }
449             tty_printf("\n");
450             /* FIXME: update the trustdb */
451         }
452     }
453     if( inv_sigs )
454         tty_printf("%d bad signatures\n", inv_sigs );
455     if( no_key )
456         tty_printf("No public key for %d signatures\n", no_key );
457     if( oth_err )
458         tty_printf("%d signatures not checked due to errors\n", oth_err );
459     return inv_sigs || no_key || oth_err;
460 }
461
462
463 /****************
464  * Ask and remove invalid signatures are to be removed.
465  */
466 static int
467 remove_keysigs( KBNODE keyblock, int all )
468 {
469     KBNODE kbctx;
470     KBNODE node;
471     char *answer;
472     int yes;
473     int count;
474
475     count = 0;
476     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
477         if( ((node->flag & 7) || all )
478             && node->pkt->pkttype == PKT_SIGNATURE
479             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
480             PKT_signature *sig = node->pkt->pkt.signature;
481
482             if( all ) {
483                 /* fixme: skip self-sig */
484             }
485
486             tty_printf("\n \"%08lX %s   ",
487                         sig->keyid[1], datestr_from_sig(sig));
488             if( node->flag & 6 )
489                 tty_printf("[User name not available] ");
490             else {
491                 size_t n;
492                 char *p = get_user_id( sig->keyid, &n );
493                 tty_print_string( p, n );
494                 m_free(p);
495             }
496             tty_printf("\"\n");
497             if( node->flag & 1 )
498                 tty_printf("This is a BAD signature!\n");
499             else if( node->flag & 2 )
500                 tty_printf("Public key not available.\n");
501             else if( node->flag & 4 )
502                 tty_printf("The signature could not be checked!\n");
503             answer = tty_get("\nRemove this signature? ");
504             tty_kill_prompt();
505             if( answer_is_yes(answer) ) {
506                 node->flag |= 128;     /* use bit 7 to mark this node */
507                 count++;
508             }
509             m_free(answer);
510         }
511     }
512
513     if( !count )
514         return 0; /* nothing to remove */
515     answer = tty_get("Do you really want to remove the selected signatures? ");
516     tty_kill_prompt();
517     yes = answer_is_yes(answer);
518     m_free(answer);
519     if( !yes )
520         return 0;
521
522     for( kbctx=NULL; (node=walk_kbtree2( keyblock, &kbctx, 1)) ; ) {
523         if( node->flag & 128)
524             delete_kbnode( keyblock, node );
525     }
526
527     return 1;
528 }
529
530
531 /****************
532  * This functions signs the key of USERNAME with all users listed in
533  * LOCUSR. If LOCUSR is NULL the default secret certificate will
534  * be used.  This works on all keyrings, so there is no armor or
535  * compress stuff here.
536  */
537 int
538 sign_key( const char *username, STRLIST locusr )
539 {
540     md_filter_context_t mfx;
541     int rc = 0;
542     SKC_LIST skc_list = NULL;
543     SKC_LIST skc_rover = NULL;
544     KBNODE keyblock = NULL;
545     KBNODE kbctx, node;
546     KBPOS kbpos;
547     PKT_public_cert *pkc;
548     u32 pkc_keyid[2];
549     char *answer;
550
551     memset( &mfx, 0, sizeof mfx);
552
553     /* search the userid */
554     rc = find_keyblock_byname( &kbpos, username );
555     if( rc ) {
556         log_error("user '%s' not found\n", username );
557         goto leave;
558     }
559
560     /* build a list of all signators */
561     rc=build_skc_list( locusr, &skc_list, 0 );
562     if( rc )
563         goto leave;
564
565
566     /* read the keyblock */
567     rc = read_keyblock( &kbpos, &keyblock );
568     if( rc ) {
569         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
570         goto leave;
571     }
572
573     /* get the keyid from the keyblock */
574     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
575         if( node->pkt->pkttype == PKT_PUBLIC_CERT )
576             break;
577     }
578     if( !node ) {
579         log_error("Oops; public key not found anymore!\n");
580         rc = G10ERR_GENERAL;
581         goto leave;
582     }
583
584     pkc = node->pkt->pkt.public_cert;
585     keyid_from_pkc( pkc, pkc_keyid );
586     log_info("Checking signatures of this public key certificate:\n");
587     tty_printf("pub  %4u%c/%08lX %s   ",
588               nbits_from_pkc( pkc ),
589               pubkey_letter( pkc->pubkey_algo ),
590               pkc_keyid[1], datestr_from_pkc(pkc) );
591     {
592         size_t n;
593         char *p = get_user_id( pkc_keyid, &n );
594         tty_print_string( p, n > 40? 40 : n );
595         m_free(p);
596         tty_printf("\n");
597     }
598
599     clear_kbnode_flags( keyblock );
600     if( check_all_keysigs( keyblock ) ) {
601         if( !opt.batch ) {
602             /* ask wether we really should do anything */
603             answer = tty_get("To you want to remove some of the invalid sigs? ");
604             tty_kill_prompt();
605             if( answer_is_yes(answer) )
606                 remove_keysigs( keyblock, 0 );
607             m_free(answer);
608         }
609     }
610
611     /* check wether we have already signed it */
612     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
613         u32 akeyid[2];
614
615         keyid_from_skc( skc_rover->skc, akeyid );
616         for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
617             if( node->pkt->pkttype == PKT_SIGNATURE
618                 && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
619                 if( akeyid[0] == node->pkt->pkt.signature->keyid[0]
620                     && akeyid[1] == node->pkt->pkt.signature->keyid[1] ) {
621                     log_info("Already signed by keyid %08lX\n", akeyid[1] );
622                     skc_rover->mark = 1;
623                 }
624             }
625         }
626     }
627     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
628         if( !skc_rover->mark )
629             break;
630     }
631     if( !skc_rover ) {
632         log_info("Nothing to sign\n");
633         goto leave;
634     }
635
636     /* Loop over all signers and all user ids and sign */
637     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
638         if( skc_rover->mark )
639             continue;
640         for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
641             if( node->pkt->pkttype == PKT_USER_ID ) {
642                 if( sign_it_p( pkc, node->pkt->pkt.user_id ) ) {
643                     PACKET *pkt;
644                     PKT_signature *sig;
645
646                     rc = make_keysig_packet( &sig, pkc,
647                                                    node->pkt->pkt.user_id,
648                                                    skc_rover->skc,
649                                                    0x10,
650                                                    DIGEST_ALGO_RMD160 );
651                     if( rc ) {
652                         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc));
653                         goto leave;
654                     }
655
656                     pkt = m_alloc_clear( sizeof *pkt );
657                     pkt->pkttype = PKT_SIGNATURE;
658                     pkt->pkt.signature = sig;
659                     add_kbnode_as_child( node, new_kbnode( pkt ) );
660                 }
661             }
662         }
663     }
664
665     rc = update_keyblock( &kbpos, keyblock );
666     if( rc ) {
667         log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
668         goto leave;
669     }
670
671   leave:
672     release_kbnode( keyblock );
673     release_skc_list( skc_list );
674     md_close( mfx.md );
675     return rc;
676 }
677
678
679
680 int
681 edit_keysigs( const char *username )
682 {
683     int rc = 0;
684     KBNODE keyblock = NULL;
685     KBNODE kbctx, node;
686     KBPOS kbpos;
687     PKT_public_cert *pkc;
688     u32 pkc_keyid[2];
689
690     /* search the userid */
691     rc = find_keyblock_byname( &kbpos, username );
692     if( rc ) {
693         log_error("user '%s' not found\n", username );
694         goto leave;
695     }
696
697     /* read the keyblock */
698     rc = read_keyblock( &kbpos, &keyblock );
699     if( rc ) {
700         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
701         goto leave;
702     }
703
704     /* get the keyid from the keyblock */
705     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
706         if( node->pkt->pkttype == PKT_PUBLIC_CERT )
707             break;
708     }
709     if( !node ) {
710         log_error("Oops; public key not found anymore!\n");
711         rc = G10ERR_GENERAL;
712         goto leave;
713     }
714
715     pkc = node->pkt->pkt.public_cert;
716     keyid_from_pkc( pkc, pkc_keyid );
717     log_info("Checking signatures of this public key certificate:\n");
718     tty_printf("pub  %4u%c/%08lX %s   ",
719               nbits_from_pkc( pkc ),
720               pubkey_letter( pkc->pubkey_algo ),
721               pkc_keyid[1], datestr_from_pkc(pkc) );
722     {
723         size_t n;
724         char *p = get_user_id( pkc_keyid, &n );
725         tty_print_string( p, n > 40? 40 : n );
726         m_free(p);
727         tty_printf("\n");
728     }
729
730     clear_kbnode_flags( keyblock );
731     check_all_keysigs( keyblock );
732     if( remove_keysigs( keyblock, 1 ) ) {
733         rc = update_keyblock( &kbpos, keyblock );
734         if( rc ) {
735             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
736             goto leave;
737         }
738     }
739
740   leave:
741     release_kbnode( keyblock );
742     return rc;
743 }
744
745
746 int
747 change_passphrase( const char *username )
748 {
749     int rc = 0;
750     KBNODE keyblock = NULL;
751     KBNODE kbctx, node;
752     KBPOS kbpos;
753     PKT_secret_cert *skc;
754     u32 skc_keyid[2];
755     char *answer;
756     int changed=0;
757
758     /* search the userid */
759     rc = find_secret_keyblock_byname( &kbpos, username );
760     if( rc ) {
761         log_error("secret key for user '%s' not found\n", username );
762         goto leave;
763     }
764
765     /* read the keyblock */
766     rc = read_keyblock( &kbpos, &keyblock );
767     if( rc ) {
768         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
769         goto leave;
770     }
771
772     /* get the keyid from the keyblock */
773     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
774         if( node->pkt->pkttype == PKT_SECRET_CERT )
775             break;
776     }
777     if( !node ) {
778         log_error("Oops; secret key not found anymore!\n");
779         rc = G10ERR_GENERAL;
780         goto leave;
781     }
782
783     skc = node->pkt->pkt.secret_cert;
784     keyid_from_skc( skc, skc_keyid );
785     tty_printf("sec  %4u%c/%08lX %s   ",
786               nbits_from_skc( skc ),
787               pubkey_letter( skc->pubkey_algo ),
788               skc_keyid[1], datestr_from_skc(skc) );
789     {
790         size_t n;
791         char *p = get_user_id( skc_keyid, &n );
792         tty_print_string( p, n );
793         m_free(p);
794         tty_printf("\n");
795     }
796
797     clear_kbnode_flags( keyblock );
798     switch( is_secret_key_protected( skc ) ) {
799       case -1:
800         rc = G10ERR_PUBKEY_ALGO;
801         break;
802       case 0:
803         tty_printf("This key is not protected.\n");
804         break;
805       default:
806         tty_printf("Key is protected.\n");
807         rc = check_secret_key( skc );
808         break;
809     }
810
811     if( rc )
812         tty_printf("Can't edit this key: %s\n", g10_errstr(rc));
813     else {
814         DEK *dek = m_alloc_secure( sizeof *dek );
815
816         tty_printf( "Enter the new passphrase for this secret key.\n\n" );
817
818         for(;;) {
819             dek->algo = CIPHER_ALGO_BLOWFISH;
820             rc = make_dek_from_passphrase( dek , 2 );
821             if( rc == -1 ) {
822                 rc = 0;
823                 tty_printf( "You don't want a passphrase -"
824                             " this is probably a *bad* idea!\n\n");
825                 answer = tty_get("Do you really want to do this? ");
826                 tty_kill_prompt();
827                 if( answer_is_yes(answer) )
828                     changed++;
829                 m_free(answer);
830                 break;
831             }
832             else if( rc == G10ERR_PASSPHRASE ) {
833                 tty_printf("passphrase not correctly repeated; try again.\n");
834             }
835             else if( rc ) {
836                 m_free(dek); dek = NULL;
837                 log_error("Error getting the passphrase: %s\n", g10_errstr(rc));
838                 break;
839             }
840             else { /* okay */
841                 skc->d.elg.protect_algo = CIPHER_ALGO_BLOWFISH;
842                 randomize_buffer(skc->d.elg.protect.blowfish.iv, 8, 1);
843                 rc = protect_secret_key( skc, dek );
844                 if( rc )
845                     log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
846                 else
847                     changed++;
848                 break;
849             }
850         }
851         m_free(dek);
852     }
853
854
855     if( changed ) {
856         rc = update_keyblock( &kbpos, keyblock );
857         if( rc ) {
858             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
859             goto leave;
860         }
861     }
862
863   leave:
864     release_kbnode( keyblock );
865     return rc;
866 }
867
868
869 /****************
870  * Create a signature packet for the given public key certificate
871  * and the user id and return it in ret_sig. User signature class SIGCLASS
872  */
873 int
874 make_keysig_packet( PKT_signature **ret_sig, PKT_public_cert *pkc,
875                     PKT_user_id *uid, PKT_secret_cert *skc,
876                     int sigclass, int digest_algo )
877 {
878     PKT_signature *sig;
879     int rc=0;
880     MD_HANDLE md;
881
882     assert( sigclass >= 0x10 && sigclass <= 0x13 );
883     md = md_open( digest_algo, 0 );
884     /* hash the public key certificate */
885     hash_public_cert( md, pkc );
886     md_write( md, uid->name, uid->len );
887     /* and make the signature packet */
888     sig = m_alloc_clear( sizeof *sig );
889     sig->pubkey_algo = skc->pubkey_algo;
890     sig->timestamp = make_timestamp();
891     sig->sig_class = sigclass;
892
893     md_putc( md, sig->sig_class );
894     {   u32 a = sig->timestamp;
895         md_putc( md, (a >> 24) & 0xff );
896         md_putc( md, (a >> 16) & 0xff );
897         md_putc( md, (a >>  8) & 0xff );
898         md_putc( md,  a        & 0xff );
899     }
900
901     rc = complete_sig( sig, skc, md );
902
903     md_close( md );
904     if( rc )
905         free_seckey_enc( sig );
906     else
907         *ret_sig = sig;
908     return rc;
909 }
910