started with trust stuff
[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         log_bug(NULL);
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 file with name FILENAME.  If DETACHED has the value true,
68  * make a detached signature.  If FILENAME is NULL read from stdin
69  * and ignore the detached mode.  Sign the file with all secret keys
70  * which can be taken from LOCUSR, if this is NULL, use the default one
71  * If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
72  * signed data for these users.
73  */
74 int
75 sign_file( const char *filename, int detached, STRLIST locusr,
76            int encrypt, STRLIST remusr )
77 {
78     armor_filter_context_t afx;
79     compress_filter_context_t zfx;
80     md_filter_context_t mfx;
81     text_filter_context_t tfx;
82     encrypt_filter_context_t efx;
83     IOBUF inp = NULL, out = NULL;
84     PACKET pkt;
85     PKT_plaintext *pt = NULL;
86     u32 filesize;
87     int last_rc, rc = 0;
88     PKC_LIST pkc_list = NULL;
89     SKC_LIST skc_list = NULL;
90     SKC_LIST skc_rover = NULL;
91
92     memset( &afx, 0, sizeof afx);
93     memset( &zfx, 0, sizeof zfx);
94     memset( &mfx, 0, sizeof mfx);
95     memset( &tfx, 0, sizeof tfx);
96     memset( &efx, 0, sizeof efx);
97     init_packet( &pkt );
98
99     if( (rc=build_skc_list( locusr, &skc_list, 1 )) )
100         goto leave;
101     if( encrypt ) {
102         if( (rc=build_pkc_list( remusr, &pkc_list )) )
103             goto leave;
104     }
105
106     /* prepare iobufs */
107     if( !(inp = iobuf_open(filename)) ) {
108         log_error("can't open %s: %s\n", filename? filename: "[stdin]",
109                                         strerror(errno) );
110         rc = G10ERR_OPEN_FILE;
111         goto leave;
112     }
113
114     if( !(out = open_outfile( filename, opt.armor? 1: detached? 2:0 )) ) {
115         rc = G10ERR_CREATE_FILE;
116         goto leave;
117     }
118
119     /* prepare to calculate the MD over the input */
120     if( opt.textmode && opt.armor )
121         iobuf_push_filter( inp, text_filter, &tfx );
122     mfx.md = md_open(DIGEST_ALGO_RMD160, 0);
123     iobuf_push_filter( inp, md_filter, &mfx );
124
125     if( opt.armor )
126         iobuf_push_filter( out, armor_filter, &afx );
127     write_comment( out, "#Created by G10 pre-release " VERSION );
128     if( opt.compress )
129         iobuf_push_filter( out, compress_filter, &zfx );
130
131     if( encrypt ) {
132         efx.pkc_list = pkc_list;
133         /* fixme: set efx.cfx.datalen if known */
134         iobuf_push_filter( out, encrypt_filter, &efx );
135     }
136
137     /* loop over the secret certificates and build headers */
138     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
139         PKT_secret_cert *skc;
140         PKT_onepass_sig *ops;
141
142         skc = skc_rover->skc;
143         ops = m_alloc_clear( sizeof *ops );
144         ops->sig_class = opt.textmode? 0x01 : 0x00;
145         ops->digest_algo = DIGEST_ALGO_RMD160;
146         ops->pubkey_algo = skc->pubkey_algo;
147         keyid_from_skc( skc, ops->keyid );
148         ops->last = !skc_rover->next;
149
150         init_packet(&pkt);
151         pkt.pkttype = PKT_ONEPASS_SIG;
152         pkt.pkt.onepass_sig = ops;
153         rc = build_packet( out, &pkt );
154         free_packet( &pkt );
155         if( rc ) {
156             log_error("build onepass_sig packet failed: %s\n", g10_errstr(rc));
157             goto leave;
158         }
159     }
160
161
162     /* setup the inner packet */
163     if( detached ) {
164         /* read, so that the filter can calculate the digest */
165         while( iobuf_get(inp) != -1 )
166             ;
167     }
168     else {
169         if( filename ) {
170             pt = m_alloc( sizeof *pt + strlen(filename) - 1 );
171             pt->namelen = strlen(filename);
172             memcpy(pt->name, filename, pt->namelen );
173             if( !(filesize = iobuf_get_filelength(inp)) )
174                 log_info("warning: '%s' is an empty file\n", filename );
175         }
176         else { /* no filename */
177             pt = m_alloc( sizeof *pt - 1 );
178             pt->namelen = 0;
179             filesize = 0; /* stdin */
180         }
181         pt->timestamp = make_timestamp();
182         pt->mode = opt.textmode? 't':'b';
183         pt->len = filesize;
184         pt->buf = inp;
185         pkt.pkttype = PKT_PLAINTEXT;
186         pkt.pkt.plaintext = pt;
187         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
188         if( (rc = build_packet( out, &pkt )) )
189             log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
190         pt->buf = NULL;
191     }
192
193     /* loop over the secret certificates */
194     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
195         PKT_secret_cert *skc;
196         PKT_signature *sig;
197         MD_HANDLE md;
198         byte *dp;
199
200         skc = skc_rover->skc;
201
202         /* build the signature packet */
203         sig = m_alloc_clear( sizeof *sig );
204         sig->pubkey_algo = skc->pubkey_algo;
205         sig->timestamp = make_timestamp();
206         sig->sig_class = opt.textmode? 0x01 : 0x00;
207
208         md = md_copy( mfx.md );
209         md_putc( md, sig->sig_class );
210         {   u32 a = sig->timestamp;
211             md_putc( md, (a >> 24) & 0xff );
212             md_putc( md, (a >> 16) & 0xff );
213             md_putc( md, (a >>  8) & 0xff );
214             md_putc( md,  a        & 0xff );
215         }
216         md_final( md );
217         dp = md_read( md, DIGEST_ALGO_RMD160 );
218
219         if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
220             ELG_secret_key skey;
221             MPI frame;
222
223             keyid_from_skc( skc, sig->keyid );
224             sig->d.elg.digest_algo = DIGEST_ALGO_RMD160;
225             sig->d.elg.digest_start[0] = dp[0];
226             sig->d.elg.digest_start[1] = dp[1];
227             sig->d.elg.a = mpi_alloc( mpi_get_nlimbs(skc->d.elg.p) );
228             sig->d.elg.b = mpi_alloc( mpi_get_nlimbs(skc->d.elg.p) );
229             frame = encode_rmd160_value( dp, 20, mpi_get_nbits(skc->d.elg.p) );
230             skey.p = skc->d.elg.p;
231             skey.g = skc->d.elg.g;
232             skey.y = skc->d.elg.y;
233             skey.x = skc->d.elg.x;
234             elg_sign( sig->d.elg.a, sig->d.elg.b, frame, &skey);
235             memset( &skey, 0, sizeof skey );
236             mpi_free(frame);
237             if( opt.verbose ) {
238                 char *ustr = get_user_id_string( sig->keyid );
239                 log_info("ELG signature from: %s\n", ustr );
240                 m_free(ustr);
241             }
242         }
243       #ifdef HAVE_RSA_CIPHER
244         else if( sig->pubkey_algo == PUBKEY_ALGO_RSA ) {
245             RSA_secret_key skey;
246
247             keyid_from_skc( skc, sig->keyid );
248             sig->d.rsa.digest_algo = DIGEST_ALGO_RMD160;
249             sig->d.rsa.digest_start[0] = dp[0];
250             sig->d.rsa.digest_start[1] = dp[1];
251             sig->d.rsa.rsa_integer = encode_rmd160_value( dp, 20,
252                                             mpi_get_nbits(skc->d.rsa.rsa_n) );
253             skey.e = skc->d.rsa.rsa_e;
254             skey.n = skc->d.rsa.rsa_n;
255             skey.p = skc->d.rsa.rsa_p;
256             skey.q = skc->d.rsa.rsa_q;
257             skey.d = skc->d.rsa.rsa_d;
258             skey.u = skc->d.rsa.rsa_u;
259             rsa_secret( sig->d.rsa.rsa_integer, sig->d.rsa.rsa_integer, &skey);
260             memset( &skey, 0, sizeof skey );
261             if( opt.verbose ) {
262                 char *ustr = get_user_id_string( sig->keyid );
263                 log_info("RSA signature from: %s\n", ustr );
264                 m_free(ustr);
265             }
266             /* fixme: should we check wether the signature is okay? */
267         }
268       #endif/*HAVE_RSA_CIPHER*/
269         else
270             log_bug(NULL);
271
272         md_close( md );
273
274         /* and write it */
275         init_packet(&pkt);
276         pkt.pkttype = PKT_SIGNATURE;
277         pkt.pkt.signature = sig;
278         rc = build_packet( out, &pkt );
279         free_packet( &pkt );
280         if( rc ) {
281             log_error("build signature packet failed: %s\n", g10_errstr(rc) );
282             goto leave;
283         }
284     }
285
286
287   leave:
288     if( rc )
289         iobuf_cancel(out);
290     else
291         iobuf_close(out);
292     iobuf_close(inp);
293     md_close( mfx.md );
294     release_skc_list( skc_list );
295     release_pkc_list( pkc_list );
296     return rc;
297 }
298
299
300
301 static void
302 show_fingerprint( PKT_public_cert *pkc )
303 {
304     byte *array, *p;
305     size_t i, n;
306
307     p = array = fingerprint_from_pkc( pkc, &n );
308     tty_printf("             Fingerprint:");
309     if( n == 20 ) {
310         for(i=0; i < n ; i++, i++, p += 2 ) {
311             if( i == 10 )
312                 tty_printf(" ");
313             tty_printf(" %02X%02X", *p, p[1] );
314         }
315     }
316     else {
317         for(i=0; i < n ; i++, p++ ) {
318             if( i && !(i%8) )
319                 tty_printf(" ");
320             tty_printf(" %02X", *p );
321         }
322     }
323     tty_printf("\n");
324     m_free(array);
325 }
326
327
328 /****************
329  * Ask wether the user is willing to sign the key. Return true if so.
330  */
331 static int
332 sign_it_p( PKT_public_cert *pkc, PKT_user_id *uid )
333 {
334     char *answer;
335     int yes;
336
337     tty_printf("\nAre you really sure that you want so sign this key:\n\n"
338                "%4u%c/%08lX %s ",
339               nbits_from_pkc( pkc ),
340               pubkey_letter( pkc->pubkey_algo ),
341               (ulong)keyid_from_pkc( pkc, NULL ),
342               datestr_from_pkc( pkc )               );
343     tty_print_string( uid->name, uid->len );
344     tty_printf("\n");
345     show_fingerprint(pkc);
346     tty_printf("\n");
347     answer = tty_get("Sign this key? ");
348     tty_kill_prompt();
349     yes = answer_is_yes(answer);
350     m_free(answer);
351     return yes;
352 }
353
354
355 /****************
356  * Check the keysigs and set the flags to indicate errors.
357  * Usage of nodes flag bits:
358  * Bit  0 = bad signature
359  *      1 = no public key
360  *      2 = other error
361  * Returns true if error found.
362  */
363 static int
364 check_all_keysigs( KBNODE keyblock )
365 {
366     KBNODE kbctx;
367     KBNODE node;
368     int rc;
369     int inv_sigs = 0;
370     int no_key = 0;
371     int oth_err = 0;
372
373     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
374         if( node->pkt->pkttype == PKT_SIGNATURE
375             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
376             PKT_signature *sig = node->pkt->pkt.signature;
377             int sigrc;
378
379             tty_printf("sig");
380             switch( (rc = check_key_signature( keyblock, node )) ) {
381               case 0:                node->flag = 0; sigrc = '!'; break;
382               case G10ERR_BAD_SIGN:  inv_sigs++; node->flag = 1; sigrc = '-'; break;
383               case G10ERR_NO_PUBKEY: no_key++;   node->flag = 2; sigrc = '?'; break;
384               default:               oth_err++;  node->flag = 4; sigrc = '%'; break;
385             }
386             tty_printf("%c       %08lX %s   ",
387                     sigrc, sig->keyid[1], datestr_from_sig(sig));
388             if( sigrc == '%' )
389                 tty_printf("[%s] ", g10_errstr(rc) );
390             else if( sigrc == '?' )
391                 ;
392             else {
393                 size_t n;
394                 char *p = get_user_id( sig->keyid, &n );
395                 tty_print_string( p, n > 40? 40 : n );
396                 m_free(p);
397             }
398             tty_printf("\n");
399             /* FIXME: update the trustdb */
400         }
401     }
402     if( inv_sigs )
403         tty_printf("%d bad signatures\n", inv_sigs );
404     if( no_key )
405         tty_printf("No public key for %d signatures\n", no_key );
406     if( oth_err )
407         tty_printf("%d signatures not checked due to errors\n", oth_err );
408     return inv_sigs || no_key || oth_err;
409 }
410
411
412 /****************
413  * Ask and remove invalid signatures are to be removed.
414  */
415 static int
416 remove_keysigs( KBNODE keyblock, int all )
417 {
418     KBNODE kbctx;
419     KBNODE node;
420     char *answer;
421     int yes;
422     int count;
423
424     count = 0;
425     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
426         if( ((node->flag & 7) || all )
427             && node->pkt->pkttype == PKT_SIGNATURE
428             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
429             PKT_signature *sig = node->pkt->pkt.signature;
430             int sigrc;
431
432             if( all ) {
433                 /* fixme: skip self-sig */
434             }
435
436             tty_printf("\n \"%08lX %s   ",
437                         sig->keyid[1], datestr_from_sig(sig));
438             if( node->flag & 6 )
439                 tty_printf("[User name not available] ");
440             else {
441                 size_t n;
442                 char *p = get_user_id( sig->keyid, &n );
443                 tty_print_string( p, n );
444                 m_free(p);
445             }
446             tty_printf("\"\n");
447             if( node->flag & 1 )
448                 tty_printf("This is a BAD signature!\n");
449             else if( node->flag & 2 )
450                 tty_printf("Public key not available.\n");
451             else if( node->flag & 4 )
452                 tty_printf("The signature could not be checked!\n");
453             answer = tty_get("\nRemove this signature? ");
454             tty_kill_prompt();
455             if( answer_is_yes(answer) ) {
456                 node->flag |= 128;     /* use bit 7 to mark this node */
457                 count++;
458             }
459             m_free(answer);
460         }
461     }
462
463     if( !count )
464         return 0; /* nothing to remove */
465     answer = tty_get("Do you really want to remove the selected signatures? ");
466     tty_kill_prompt();
467     yes = answer_is_yes(answer);
468     m_free(answer);
469     if( !yes )
470         return 0;
471
472     for( kbctx=NULL; (node=walk_kbtree2( keyblock, &kbctx, 1)) ; ) {
473         if( node->flag & 128)
474             delete_kbnode( keyblock, node );
475     }
476
477     return 1;
478 }
479
480
481 /****************
482  * This functions signs the key of USERNAME with all users listed in
483  * LOCUSR. If LOCUSR is NULL the default secret certificate will
484  * be used.  This works on all keyrings, so there is no armor or
485  * compress stuff here.
486  */
487 int
488 sign_key( const char *username, STRLIST locusr )
489 {
490     md_filter_context_t mfx;
491     int rc = 0;
492     SKC_LIST skc_list = NULL;
493     SKC_LIST skc_rover = NULL;
494     KBNODE keyblock = NULL;
495     KBNODE kbctx, node;
496     KBPOS kbpos;
497     PKT_public_cert *pkc;
498     int any;
499     u32 pkc_keyid[2];
500     char *answer;
501
502     memset( &mfx, 0, sizeof mfx);
503
504     /* search the userid */
505     rc = search_keyblock_byname( &kbpos, username );
506     if( rc ) {
507         log_error("user '%s' not found\n", username );
508         goto leave;
509     }
510
511     /* build a list of all signators */
512     rc=build_skc_list( locusr, &skc_list, 0 );
513     if( rc )
514         goto leave;
515
516
517     /* read the keyblock */
518     rc = read_keyblock( &kbpos, &keyblock );
519     if( rc ) {
520         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
521         goto leave;
522     }
523
524     /* get the keyid from the keyblock */
525     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
526         if( node->pkt->pkttype == PKT_PUBLIC_CERT )
527             break;
528     }
529     if( !node ) {
530         log_error("Oops; public key not found anymore!\n");
531         rc = G10ERR_GENERAL;
532         goto leave;
533     }
534
535     pkc = node->pkt->pkt.public_cert;
536     keyid_from_pkc( pkc, pkc_keyid );
537     log_info("Checking signatures of this public key certificate:\n");
538     tty_printf("pub  %4u%c/%08lX %s   ",
539               nbits_from_pkc( pkc ),
540               pubkey_letter( pkc->pubkey_algo ),
541               pkc_keyid[1], datestr_from_pkc(pkc) );
542     {
543         size_t n;
544         char *p = get_user_id( pkc_keyid, &n );
545         tty_print_string( p, n > 40? 40 : n );
546         m_free(p);
547         tty_printf("\n");
548     }
549
550     clear_kbnode_flags( keyblock );
551     if( check_all_keysigs( keyblock ) ) {
552         if( !opt.batch ) {
553             /* ask wether we really should do anything */
554             answer = tty_get("To you want to remove some of the invalid sigs? ");
555             tty_kill_prompt();
556             if( answer_is_yes(answer) )
557                 remove_keysigs( keyblock, 0 );
558             m_free(answer);
559         }
560     }
561
562     /* check wether we have already signed it */
563     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
564         u32 akeyid[2];
565
566         keyid_from_skc( skc_rover->skc, akeyid );
567         for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
568             if( node->pkt->pkttype == PKT_SIGNATURE
569                 && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
570                 if( akeyid[0] == node->pkt->pkt.signature->keyid[0]
571                     && akeyid[1] == node->pkt->pkt.signature->keyid[1] ) {
572                     log_info("Already signed by keyid %08lX\n", akeyid[1] );
573                     skc_rover->mark = 1;
574                 }
575             }
576         }
577     }
578     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
579         if( !skc_rover->mark )
580             break;
581     }
582     if( !skc_rover ) {
583         log_info("Nothing to sign\n");
584         goto leave;
585     }
586
587     /* Loop over all signers and all user ids and sign */
588     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
589         if( skc_rover->mark )
590             continue;
591         for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
592             if( node->pkt->pkttype == PKT_USER_ID ) {
593                 if( sign_it_p( pkc, node->pkt->pkt.user_id ) ) {
594                     PACKET *pkt;
595                     PKT_signature *sig;
596
597                     rc = make_keysig_packet( &sig, pkc,
598                                                    node->pkt->pkt.user_id,
599                                                    skc_rover->skc,
600                                                    0x10,
601                                                    DIGEST_ALGO_RMD160 );
602                     if( rc ) {
603                         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc));
604                         goto leave;
605                     }
606
607                     pkt = m_alloc_clear( sizeof *pkt );
608                     pkt->pkttype = PKT_SIGNATURE;
609                     pkt->pkt.signature = sig;
610                     add_kbnode_as_child( node, new_kbnode( pkt ) );
611                 }
612             }
613         }
614     }
615
616     rc = update_keyblock( &kbpos, keyblock );
617     if( rc ) {
618         log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
619         goto leave;
620     }
621
622   leave:
623     release_kbnode( keyblock );
624     release_skc_list( skc_list );
625     md_close( mfx.md );
626     return rc;
627 }
628
629
630
631 int
632 edit_keysigs( const char *username )
633 {
634     int rc = 0;
635     KBNODE keyblock = NULL;
636     KBNODE kbctx, node;
637     KBPOS kbpos;
638     PKT_public_cert *pkc;
639     int any;
640     u32 pkc_keyid[2];
641     char *answer;
642
643     /* search the userid */
644     rc = search_keyblock_byname( &kbpos, username );
645     if( rc ) {
646         log_error("user '%s' not found\n", username );
647         goto leave;
648     }
649
650     /* read the keyblock */
651     rc = read_keyblock( &kbpos, &keyblock );
652     if( rc ) {
653         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
654         goto leave;
655     }
656
657     /* get the keyid from the keyblock */
658     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
659         if( node->pkt->pkttype == PKT_PUBLIC_CERT )
660             break;
661     }
662     if( !node ) {
663         log_error("Oops; public key not found anymore!\n");
664         rc = G10ERR_GENERAL;
665         goto leave;
666     }
667
668     pkc = node->pkt->pkt.public_cert;
669     keyid_from_pkc( pkc, pkc_keyid );
670     log_info("Checking signatures of this public key certificate:\n");
671     tty_printf("pub  %4u%c/%08lX %s   ",
672               nbits_from_pkc( pkc ),
673               pubkey_letter( pkc->pubkey_algo ),
674               pkc_keyid[1], datestr_from_pkc(pkc) );
675     {
676         size_t n;
677         char *p = get_user_id( pkc_keyid, &n );
678         tty_print_string( p, n > 40? 40 : n );
679         m_free(p);
680         tty_printf("\n");
681     }
682
683     clear_kbnode_flags( keyblock );
684     check_all_keysigs( keyblock );
685     if( remove_keysigs( keyblock, 1 ) ) {
686         rc = update_keyblock( &kbpos, keyblock );
687         if( rc ) {
688             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
689             goto leave;
690         }
691     }
692
693   leave:
694     release_kbnode( keyblock );
695     return rc;
696 }
697
698
699 int
700 change_passphrase( const char *username )
701 {
702     int rc = 0;
703     KBNODE keyblock = NULL;
704     KBNODE kbctx, node;
705     KBPOS kbpos;
706     PKT_secret_cert *skc;
707     int any;
708     u32 skc_keyid[2];
709     char *answer;
710     int changed=0;
711
712     /* search the userid */
713     rc = search_secret_keyblock_byname( &kbpos, username );
714     if( rc ) {
715         log_error("secret key for user '%s' not found\n", username );
716         goto leave;
717     }
718
719     /* read the keyblock */
720     rc = read_keyblock( &kbpos, &keyblock );
721     if( rc ) {
722         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
723         goto leave;
724     }
725
726     /* get the keyid from the keyblock */
727     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
728         if( node->pkt->pkttype == PKT_SECRET_CERT )
729             break;
730     }
731     if( !node ) {
732         log_error("Oops; secret key not found anymore!\n");
733         rc = G10ERR_GENERAL;
734         goto leave;
735     }
736
737     skc = node->pkt->pkt.secret_cert;
738     keyid_from_skc( skc, skc_keyid );
739     tty_printf("sec  %4u%c/%08lX %s   ",
740               nbits_from_skc( skc ),
741               pubkey_letter( skc->pubkey_algo ),
742               skc_keyid[1], datestr_from_skc(skc) );
743     {
744         size_t n;
745         char *p = get_user_id( skc_keyid, &n );
746         tty_print_string( p, n );
747         m_free(p);
748         tty_printf("\n");
749     }
750
751     clear_kbnode_flags( keyblock );
752     switch( is_secret_key_protected( skc ) ) {
753       case -1:
754         rc = G10ERR_PUBKEY_ALGO;
755         break;
756       case 0:
757         tty_printf("This key is not protected.\n");
758         break;
759       default:
760         tty_printf("Key is protected.\n");
761         rc = check_secret_key( skc );
762         break;
763     }
764
765     if( rc )
766         tty_printf("Can't edit this key: %s\n", g10_errstr(rc));
767     else {
768         DEK *dek = m_alloc_secure( sizeof *dek );
769
770         tty_printf( "Enter the new passphrase for this secret key.\n\n" );
771
772         for(;;) {
773             dek->algo = CIPHER_ALGO_BLOWFISH;
774             rc = make_dek_from_passphrase( dek , 2 );
775             if( rc == -1 ) {
776                 rc = 0;
777                 tty_printf( "You don't want a passphrase -"
778                             " this is probably a *bad* idea!\n\n");
779                 answer = tty_get("Do you really want to do this? ");
780                 tty_kill_prompt();
781                 if( answer_is_yes(answer) )
782                     changed++;
783                 m_free(answer);
784                 break;
785             }
786             else if( rc == G10ERR_PASSPHRASE ) {
787                 tty_printf("passphrase not correctly repeated; try again.\n");
788             }
789             else if( rc ) {
790                 m_free(dek); dek = NULL;
791                 log_error("Error getting the passphrase: %s\n", g10_errstr(rc));
792                 break;
793             }
794             else { /* okay */
795                 skc->d.elg.protect_algo = CIPHER_ALGO_BLOWFISH;
796                 randomize_buffer(skc->d.elg.protect.blowfish.iv, 8, 1);
797                 rc = protect_secret_key( skc, dek );
798                 if( rc )
799                     log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
800                 else
801                     changed++;
802                 break;
803             }
804         }
805         m_free(dek);
806     }
807
808
809     if( changed ) {
810         rc = update_keyblock( &kbpos, keyblock );
811         if( rc ) {
812             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
813             goto leave;
814         }
815     }
816
817   leave:
818     release_kbnode( keyblock );
819     return rc;
820 }
821
822
823 /****************
824  * Create a signature packet for the given public key certificate
825  * and the user id and return it in ret_sig. User signature class SIGCLASS
826  */
827 int
828 make_keysig_packet( PKT_signature **ret_sig, PKT_public_cert *pkc,
829                     PKT_user_id *uid, PKT_secret_cert *skc,
830                     int sigclass, int digest_algo )
831 {
832     PKT_signature *sig;
833     int rc=0;
834     MD_HANDLE md;
835
836     assert( sigclass >= 0x10 && sigclass <= 0x13 );
837     md = md_open( digest_algo, 0 );
838     /* hash the public key certificate */
839     hash_public_cert( md, pkc );
840     md_write( md, uid->name, uid->len );
841     /* and make the signature packet */
842     sig = m_alloc_clear( sizeof *sig );
843     sig->pubkey_algo = skc->pubkey_algo;
844     sig->timestamp = make_timestamp();
845     sig->sig_class = sigclass;
846
847     md_putc( md, sig->sig_class );
848     {   u32 a = sig->timestamp;
849         md_putc( md, (a >> 24) & 0xff );
850         md_putc( md, (a >> 16) & 0xff );
851         md_putc( md, (a >>  8) & 0xff );
852         md_putc( md,  a        & 0xff );
853     }
854
855     rc = complete_sig( sig, skc, md );
856
857     md_close( md );
858     if( rc )
859         free_seckey_enc( sig );
860     else
861         *ret_sig = sig;
862     return rc;
863 }
864