add DSA key generation
[gnupg.git] / g10 / keyedit.c
1 /* keyedit.c - keyedit stuff
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG 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  * GNUPG 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 #include "i18n.h"
39
40
41
42 static void
43 show_fingerprint( PKT_public_cert *pkc )
44 {
45     byte *array, *p;
46     size_t i, n;
47
48     p = array = fingerprint_from_pkc( pkc, &n );
49     tty_printf("             Fingerprint:");
50     if( n == 20 ) {
51         for(i=0; i < n ; i++, i++, p += 2 ) {
52             if( i == 10 )
53                 tty_printf(" ");
54             tty_printf(" %02X%02X", *p, p[1] );
55         }
56     }
57     else {
58         for(i=0; i < n ; i++, p++ ) {
59             if( i && !(i%8) )
60                 tty_printf(" ");
61             tty_printf(" %02X", *p );
62         }
63     }
64     tty_printf("\n");
65     m_free(array);
66 }
67
68
69 /****************
70  * Ask whether the user is willing to sign the key. Return true if so.
71  */
72 static int
73 sign_it_p( PKT_public_cert *pkc, PKT_user_id *uid )
74 {
75     char *answer;
76     int yes;
77
78     tty_printf("\nAre you really sure that you want to sign this key:\n\n"
79                "%4u%c/%08lX %s ",
80               nbits_from_pkc( pkc ),
81               pubkey_letter( pkc->pubkey_algo ),
82               (ulong)keyid_from_pkc( pkc, NULL ),
83               datestr_from_pkc( pkc )               );
84     tty_print_string( uid->name, uid->len );
85     tty_printf("\n");
86     show_fingerprint(pkc);
87     tty_printf("\n");
88     answer = tty_get("Sign this key? ");
89     tty_kill_prompt();
90     yes = answer_is_yes(answer);
91     m_free(answer);
92     return yes;
93 }
94
95
96 /****************
97  * Check the keysigs and set the flags to indicate errors.
98  * Usage of nodes flag bits:
99  * Bit  0 = bad signature
100  *      1 = no public key
101  *      2 = other error
102  * Returns true if error found.
103  */
104 static int
105 check_all_keysigs( KBNODE keyblock )
106 {
107     KBNODE kbctx;
108     KBNODE node;
109     int rc;
110     int inv_sigs = 0;
111     int no_key = 0;
112     int oth_err = 0;
113
114     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
115         if( node->pkt->pkttype == PKT_SIGNATURE
116             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
117             PKT_signature *sig = node->pkt->pkt.signature;
118             int sigrc;
119
120             tty_printf("sig");
121             switch( (rc = check_key_signature( keyblock, node,NULL)) ) {
122               case 0:                node->flag = 0; sigrc = '!'; break;
123               case G10ERR_BAD_SIGN:  inv_sigs++; node->flag = 1; sigrc = '-'; break;
124               case G10ERR_NO_PUBKEY: no_key++;   node->flag = 2; sigrc = '?'; break;
125               default:               oth_err++;  node->flag = 4; sigrc = '%'; break;
126             }
127             tty_printf("%c       %08lX %s   ",
128                     sigrc, sig->keyid[1], datestr_from_sig(sig));
129             if( sigrc == '%' )
130                 tty_printf("[%s] ", g10_errstr(rc) );
131             else if( sigrc == '?' )
132                 ;
133             else {
134                 size_t n;
135                 char *p = get_user_id( sig->keyid, &n );
136                 tty_print_string( p, n > 40? 40 : n );
137                 m_free(p);
138             }
139             tty_printf("\n");
140             /* FIXME: update the trustdb */
141         }
142     }
143     if( inv_sigs )
144         tty_printf("%d bad signatures\n", inv_sigs );
145     if( no_key )
146         tty_printf("No public key for %d signatures\n", no_key );
147     if( oth_err )
148         tty_printf("%d signatures not checked due to errors\n", oth_err );
149     return inv_sigs || no_key || oth_err;
150 }
151
152
153 /****************
154  * Ask and remove invalid signatures that are to be removed.
155  */
156 static int
157 remove_keysigs( KBNODE keyblock, u32 *keyid, int all )
158 {
159     KBNODE kbctx;
160     KBNODE node;
161     char *answer;
162     int yes;
163     int count;
164
165     count = 0;
166     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
167         if( ((node->flag & 7) || all )
168             && node->pkt->pkttype == PKT_SIGNATURE
169             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
170             PKT_signature *sig = node->pkt->pkt.signature;
171
172             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
173                 /* fixme: skip self-sig */
174             }
175
176             tty_printf("\n \"%08lX %s   ",
177                         sig->keyid[1], datestr_from_sig(sig));
178             if( node->flag & 6 )
179                 tty_printf("[User name not available] ");
180             else {
181                 size_t n;
182                 char *p = get_user_id( sig->keyid, &n );
183                 tty_print_string( p, n );
184                 m_free(p);
185             }
186             tty_printf("\"\n");
187             if( node->flag & 1 )
188                 tty_printf("This is a BAD signature!\n");
189             else if( node->flag & 2 )
190                 tty_printf("Public key not available.\n");
191             else if( node->flag & 4 )
192                 tty_printf("The signature could not be checked!\n");
193
194             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
195                 continue; /* do not remove self-signatures */
196
197             answer = tty_get("\nRemove this signature? ");
198             tty_kill_prompt();
199             if( answer_is_yes(answer) ) {
200                 node->flag |= 128;     /* use bit 7 to mark this node */
201                 count++;
202             }
203             m_free(answer);
204         }
205     }
206
207     if( !count )
208         return 0; /* nothing to remove */
209     answer = tty_get("Do you really want to remove the selected signatures? ");
210     tty_kill_prompt();
211     yes = answer_is_yes(answer);
212     m_free(answer);
213     if( !yes )
214         return 0;
215
216     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 1)) ; ) {
217         if( node->flag & 128)
218             delete_kbnode(node );
219     }
220
221     return 1;
222 }
223
224
225 /****************
226  * This function signs the key of USERNAME with all users listed in
227  * LOCUSR. If LOCUSR is NULL the default secret certificate will
228  * be used.  This works on all keyrings, so there is no armor or
229  * compress stuff here.
230  */
231 int
232 sign_key( const char *username, STRLIST locusr )
233 {
234     md_filter_context_t mfx;
235     int rc = 0;
236     SKC_LIST skc_list = NULL;
237     SKC_LIST skc_rover = NULL;
238     KBNODE keyblock = NULL;
239     KBNODE kbctx, node;
240     KBPOS kbpos;
241     PKT_public_cert *pkc;
242     u32 pkc_keyid[2];
243     char *answer;
244
245     memset( &mfx, 0, sizeof mfx);
246
247     /* search the userid */
248     rc = find_keyblock_byname( &kbpos, username );
249     if( rc ) {
250         log_error("user '%s' not found\n", username );
251         goto leave;
252     }
253
254     /* build a list of all signators */
255     rc=build_skc_list( locusr, &skc_list, 0, 1 );
256     if( rc )
257         goto leave;
258
259
260     /* read the keyblock */
261     rc = read_keyblock( &kbpos, &keyblock );
262     if( rc ) {
263         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
264         goto leave;
265     }
266
267     /* get the keyid from the keyblock */
268     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
269     if( !node ) {
270         log_error("Oops; public key not found anymore!\n");
271         rc = G10ERR_GENERAL;
272         goto leave;
273     }
274
275     pkc = node->pkt->pkt.public_cert;
276     keyid_from_pkc( pkc, pkc_keyid );
277     log_info("Checking signatures of this public key certificate:\n");
278     tty_printf("pub  %4u%c/%08lX %s   ",
279               nbits_from_pkc( pkc ),
280               pubkey_letter( pkc->pubkey_algo ),
281               pkc_keyid[1], datestr_from_pkc(pkc) );
282     {
283         size_t n;
284         char *p = get_user_id( pkc_keyid, &n );
285         tty_print_string( p, n > 40? 40 : n );
286         m_free(p);
287         tty_printf("\n");
288     }
289
290     clear_kbnode_flags( keyblock );
291     if( check_all_keysigs( keyblock ) ) {
292         if( !opt.batch ) {
293             /* ask whether we really should do anything */
294             answer = tty_get("To you want to remove some of the invalid sigs? ");
295             tty_kill_prompt();
296             if( answer_is_yes(answer) )
297                 remove_keysigs( keyblock, pkc_keyid, 0 );
298             m_free(answer);
299         }
300     }
301
302     /* check whether we it is possible to sign this key */
303     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
304         u32 akeyid[2];
305
306         keyid_from_skc( skc_rover->skc, akeyid );
307         for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
308             if( node->pkt->pkttype == PKT_USER_ID )
309                 skc_rover->mark = 1;
310             else if( node->pkt->pkttype == PKT_SIGNATURE
311                 && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
312                 if( akeyid[0] == node->pkt->pkt.signature->keyid[0]
313                     && akeyid[1] == node->pkt->pkt.signature->keyid[1] ) {
314                     log_info("Already signed by keyid %08lX\n",
315                                                         (ulong)akeyid[1] );
316                     skc_rover->mark = 0;
317                 }
318             }
319         }
320     }
321     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
322         if( skc_rover->mark )
323             break;
324     }
325     if( !skc_rover ) {
326         log_info("Nothing to sign\n");
327         goto leave;
328     }
329
330     /* Loop over all signers and all user ids and sign */
331     /* FIXME: we have to change it: Present all user-ids and
332      * then ask whether all those ids shall be signed if the user
333      * answers yes, go and make a 0x14 sign class packet and remove
334      * old one-user-id-only-sigs (user should be noted of this
335      * condition while presenting the user-ids); if he had answered
336      * no, present each user-id in turn and ask which one should be signed
337      * (only one) - if there is already a single-user-sig, do nothing.
338      * (this is propably already out in the world) */
339     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
340         if( !skc_rover->mark )
341             continue;
342         for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
343             if( node->pkt->pkttype == PKT_USER_ID ) {
344                 if( sign_it_p( pkc, node->pkt->pkt.user_id ) ) {
345                     PACKET *pkt;
346                     PKT_signature *sig;
347
348                     rc = make_keysig_packet( &sig, pkc,
349                                                    node->pkt->pkt.user_id,
350                                                    skc_rover->skc,
351                                                    0x10,
352                                                    DIGEST_ALGO_RMD160 );
353                     if( rc ) {
354                         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc));
355                         goto leave;
356                     }
357
358                     pkt = m_alloc_clear( sizeof *pkt );
359                     pkt->pkttype = PKT_SIGNATURE;
360                     pkt->pkt.signature = sig;
361                     insert_kbnode( node, new_kbnode(pkt), PKT_USER_ID );
362                 }
363             }
364         }
365     }
366
367     rc = update_keyblock( &kbpos, keyblock );
368     if( rc ) {
369         log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
370         goto leave;
371     }
372
373   leave:
374     release_kbnode( keyblock );
375     release_skc_list( skc_list );
376     md_close( mfx.md );
377     return rc;
378 }
379
380
381
382 int
383 edit_keysigs( const char *username )
384 {
385     int rc = 0;
386     KBNODE keyblock = NULL;
387     KBNODE node;
388     KBPOS kbpos;
389     PKT_public_cert *pkc;
390     u32 pkc_keyid[2];
391
392     /* search the userid */
393     rc = find_keyblock_byname( &kbpos, username );
394     if( rc ) {
395         log_error("%s: user not found\n", username );
396         goto leave;
397     }
398
399     /* read the keyblock */
400     rc = read_keyblock( &kbpos, &keyblock );
401     if( rc ) {
402         log_error("%s: certificate read problem: %s\n", username, g10_errstr(rc) );
403         goto leave;
404     }
405
406     /* get the keyid from the keyblock */
407     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
408     if( !node ) {
409         log_error("Oops; public key not found anymore!\n");
410         rc = G10ERR_GENERAL;
411         goto leave;
412     }
413
414     pkc = node->pkt->pkt.public_cert;
415     keyid_from_pkc( pkc, pkc_keyid );
416     log_info("Checking signatures of this public key certificate:\n");
417     tty_printf("pub  %4u%c/%08lX %s   ",
418               nbits_from_pkc( pkc ),
419               pubkey_letter( pkc->pubkey_algo ),
420               pkc_keyid[1], datestr_from_pkc(pkc) );
421     {
422         size_t n;
423         char *p = get_user_id( pkc_keyid, &n );
424         tty_print_string( p, n > 40? 40 : n );
425         m_free(p);
426         tty_printf("\n");
427     }
428
429     clear_kbnode_flags( keyblock );
430     check_all_keysigs( keyblock );
431     if( remove_keysigs( keyblock, pkc_keyid, 1 ) ) {
432         rc = update_keyblock( &kbpos, keyblock );
433         if( rc ) {
434             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
435             goto leave;
436         }
437     }
438
439   leave:
440     release_kbnode( keyblock );
441     return rc;
442 }
443
444
445 /****************
446  * Delete a public or secret key from a keyring.
447  */
448 int
449 delete_key( const char *username, int secret )
450 {
451     int rc = 0;
452     KBNODE keyblock = NULL;
453     KBNODE node;
454     KBPOS kbpos;
455     PKT_public_cert *pkc = NULL;
456     PKT_secret_cert *skc = NULL;
457     u32 keyid[2];
458     int okay=0;
459
460     /* search the userid */
461     rc = secret? find_secret_keyblock_byname( &kbpos, username )
462                : find_keyblock_byname( &kbpos, username );
463     if( rc ) {
464         log_error("%s: user not found\n", username );
465         goto leave;
466     }
467
468     /* read the keyblock */
469     rc = read_keyblock( &kbpos, &keyblock );
470     if( rc ) {
471         log_error("%s: read problem: %s\n", username, g10_errstr(rc) );
472         goto leave;
473     }
474
475     /* get the keyid from the keyblock */
476     node = find_kbnode( keyblock, secret? PKT_SECRET_CERT:PKT_PUBLIC_CERT );
477     if( !node ) {
478         log_error("Oops; key not found anymore!\n");
479         rc = G10ERR_GENERAL;
480         goto leave;
481     }
482
483     if( secret ) {
484         skc = node->pkt->pkt.secret_cert;
485         keyid_from_skc( skc, keyid );
486     }
487     else {
488         pkc = node->pkt->pkt.public_cert;
489         keyid_from_pkc( pkc, keyid );
490         rc = seckey_available( keyid );
491         if( !rc ) {
492             log_error(_(
493             "there is a secret key for this public key!\n"));
494             log_info(_(
495             "use option \"--delete-secret-key\" to delete it first.\n"));
496             rc = -1;
497         }
498         else if( rc != G10ERR_NO_SECKEY )
499             log_error("%s: get secret key: %s\n", username, g10_errstr(rc) );
500         else
501             rc = 0;
502     }
503
504     if( rc )
505         rc = 0;
506     else if( opt.batch && secret )
507         log_error(_("can't do that in batch-mode\n"));
508     else if( opt.batch && opt.answer_yes )
509         okay++;
510     else if( opt.batch )
511         log_error(_("can't do that in batch-mode without \"--yes\"\n"));
512     else {
513         char *p;
514         size_t n;
515
516         if( secret )
517             tty_printf("sec  %4u%c/%08lX %s   ",
518                       nbits_from_skc( skc ),
519                       pubkey_letter( skc->pubkey_algo ),
520                       keyid[1], datestr_from_skc(skc) );
521         else
522             tty_printf("pub  %4u%c/%08lX %s   ",
523                       nbits_from_pkc( pkc ),
524                       pubkey_letter( pkc->pubkey_algo ),
525                       keyid[1], datestr_from_pkc(pkc) );
526         p = get_user_id( keyid, &n );
527         tty_print_string( p, n );
528         m_free(p);
529         tty_printf("\n\n");
530
531         p = tty_get(_("Delete this key from the keyring? "));
532         tty_kill_prompt();
533         if( secret && answer_is_yes(p)) {
534             /* I think it is not required to check a passphrase; if
535              * the user is so stupid as to let others access his secret keyring
536              * (and has no backup) - it is up him to read some very
537              * basic texts about security.
538              */
539             m_free(p);
540             p = tty_get(_("This is a secret key! - really delete? "));
541         }
542         if( answer_is_yes(p) )
543             okay++;
544         m_free(p);
545     }
546
547
548     if( okay ) {
549         rc = delete_keyblock( &kbpos );
550         if( rc ) {
551             log_error("delete_keyblock failed: %s\n", g10_errstr(rc) );
552             goto leave;
553         }
554     }
555
556   leave:
557     release_kbnode( keyblock );
558     return rc;
559 }
560
561
562 int
563 change_passphrase( const char *username )
564 {
565     int rc = 0;
566     KBNODE keyblock = NULL;
567     KBNODE node;
568     KBPOS kbpos;
569     PKT_secret_cert *skc;
570     u32 skc_keyid[2];
571     char *answer;
572     int changed=0;
573
574     /* find the userid */
575     rc = find_secret_keyblock_byname( &kbpos, username );
576     if( rc ) {
577         log_error("secret key for user '%s' not found\n", username );
578         goto leave;
579     }
580
581     /* read the keyblock */
582     rc = read_keyblock( &kbpos, &keyblock );
583     if( rc ) {
584         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
585         goto leave;
586     }
587
588     /* get the keyid from the keyblock */
589     node = find_kbnode( keyblock, PKT_SECRET_CERT );
590     if( !node ) {
591         log_error("Oops; secret key not found anymore!\n");
592         rc = G10ERR_GENERAL;
593         goto leave;
594     }
595
596     skc = node->pkt->pkt.secret_cert;
597     keyid_from_skc( skc, skc_keyid );
598     tty_printf("sec  %4u%c/%08lX %s   ",
599               nbits_from_skc( skc ),
600               pubkey_letter( skc->pubkey_algo ),
601               skc_keyid[1], datestr_from_skc(skc) );
602     {
603         size_t n;
604         char *p = get_user_id( skc_keyid, &n );
605         tty_print_string( p, n );
606         m_free(p);
607         tty_printf("\n");
608     }
609
610     clear_kbnode_flags( keyblock );
611     switch( is_secret_key_protected( skc ) ) {
612       case -1:
613         rc = G10ERR_PUBKEY_ALGO;
614         break;
615       case 0:
616         tty_printf("This key is not protected.\n");
617         break;
618       default:
619         tty_printf("Key is protected.\n");
620         rc = check_secret_key( skc );
621         break;
622     }
623
624     /* fixme: unprotect all subkeys */
625
626     if( rc )
627         tty_printf("Can't edit this key: %s\n", g10_errstr(rc));
628     else {
629         DEK *dek = NULL;
630         STRING2KEY *s2k = m_alloc_secure( sizeof *s2k );
631
632         tty_printf(_("Enter the new passphrase for this secret key.\n\n") );
633
634         for(;;) {
635             s2k->mode = 1;
636             s2k->hash_algo = DIGEST_ALGO_RMD160;
637             dek = passphrase_to_dek( NULL, CIPHER_ALGO_BLOWFISH, s2k, 2 );
638             if( !dek ) {
639                 tty_printf(_("passphrase not correctly repeated; try again.\n"));
640             }
641             else if( !dek->keylen ) {
642                 rc = 0;
643                 tty_printf(_( "You don't want a passphrase -"
644                             " this is probably a *bad* idea!\n\n"));
645                 answer = tty_get(_("Do you really want to do this? "));
646                 tty_kill_prompt();
647                 if( answer_is_yes(answer) )
648                     changed++;
649                 m_free(answer);
650                 break;
651             }
652             else { /* okay */
653                 /* fixme: protect all subkeys too */
654                 skc->protect.algo = dek->algo;
655                 skc->protect.s2k = *s2k;
656                 rc = protect_secret_key( skc, dek );
657                 if( rc )
658                     log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
659                 else
660                     changed++;
661                 break;
662             }
663         }
664         m_free(s2k);
665         m_free(dek);
666     }
667
668
669     if( changed ) {
670         rc = update_keyblock( &kbpos, keyblock );
671         if( rc ) {
672             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
673             goto leave;
674         }
675     }
676
677   leave:
678     release_kbnode( keyblock );
679     return rc;
680 }
681
682
683 /****************
684  * Create a signature packet for the given public key certificate
685  * and the user id and return it in ret_sig. User signature class SIGCLASS
686  * user-id is not used (and may be NULL if sigclass is 0x20)
687  */
688 int
689 make_keysig_packet( PKT_signature **ret_sig, PKT_public_cert *pkc,
690                     PKT_user_id *uid, PKT_secret_cert *skc,
691                     int sigclass, int digest_algo )
692 {
693     PKT_signature *sig;
694     int rc=0;
695     MD_HANDLE md;
696
697     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x20 );
698     md = md_open( digest_algo, 0 );
699
700     /* hash the public key certificate and the user id */
701     hash_public_cert( md, pkc );
702     if( sigclass != 0x20 )
703         md_write( md, uid->name, uid->len );
704     /* and make the signature packet */
705     sig = m_alloc_clear( sizeof *sig );
706     sig->pubkey_algo = skc->pubkey_algo;
707     sig->timestamp = make_timestamp();
708     sig->sig_class = sigclass;
709
710     md_putc( md, sig->sig_class );
711     {   u32 a = sig->timestamp;
712         md_putc( md, (a >> 24) & 0xff );
713         md_putc( md, (a >> 16) & 0xff );
714         md_putc( md, (a >>  8) & 0xff );
715         md_putc( md,  a        & 0xff );
716     }
717     md_final(md);
718
719     rc = complete_sig( sig, skc, md );
720
721     md_close( md );
722     if( rc )
723         free_seckey_enc( sig );
724     else
725         *ret_sig = sig;
726     return rc;
727 }
728