test release
[gnupg.git] / g10 / sign.c
1 /* sign.c - sign data
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
43
44 static int
45 complete_sig( PKT_signature *sig, PKT_secret_cert *skc, MD_HANDLE md )
46 {
47     int rc=0;
48
49     if( (rc=check_secret_key( skc )) )
50         ;
51     else if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
52         g10_elg_sign( skc, sig, md, 0 );
53     else if( sig->pubkey_algo == PUBKEY_ALGO_DSA )
54         g10_dsa_sign( skc, sig, md, 0 );
55     else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
56         g10_rsa_sign( skc, sig, md, 0 );
57     else
58         BUG();
59
60     /* fixme: should we check wether the signature is okay?
61      * maybe by using an option */
62
63     return rc;
64 }
65
66
67
68
69
70 /****************
71  * Sign the files whose names are in FILENAME.
72  * If DETACHED has the value true,
73  * make a detached signature.  If FILENAMES->d is NULL read from stdin
74  * and ignore the detached mode.  Sign the file with all secret keys
75  * which can be taken from LOCUSR, if this is NULL, use the default one
76  * If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
77  * signed data for these users.
78  * If OUTFILE is not NULL; this file is used for output and the function
79  * does not ask for overwrite permission; output is then always
80  * uncompressed, non-armored and in binary mode.
81  */
82 int
83 sign_file( STRLIST filenames, int detached, STRLIST locusr,
84            int encrypt, STRLIST remusr, const char *outfile )
85 {
86     const char *fname;
87     armor_filter_context_t afx;
88     compress_filter_context_t zfx;
89     md_filter_context_t mfx;
90     text_filter_context_t tfx;
91     encrypt_filter_context_t efx;
92     IOBUF inp = NULL, out = NULL;
93     PACKET pkt;
94     PKT_plaintext *pt = NULL;
95     u32 filesize;
96     int rc = 0;
97     PKC_LIST pkc_list = NULL;
98     SKC_LIST skc_list = NULL;
99     SKC_LIST skc_rover = NULL;
100     int multifile = 0;
101
102     memset( &afx, 0, sizeof afx);
103     memset( &zfx, 0, sizeof zfx);
104     memset( &mfx, 0, sizeof mfx);
105     memset( &tfx, 0, sizeof tfx);
106     memset( &efx, 0, sizeof efx);
107     init_packet( &pkt );
108
109     if( filenames ) {
110         fname = filenames->d;
111         multifile = !!filenames->next;
112     }
113     else
114         fname = NULL;
115
116     if( fname && filenames->next && (!detached || encrypt) )
117         log_bug("multiple files can only be detached signed");
118
119     if( (rc=build_skc_list( locusr, &skc_list, 1, 1 )) )
120         goto leave;
121     if( encrypt ) {
122         if( (rc=build_pkc_list( remusr, &pkc_list, 2 )) )
123             goto leave;
124     }
125
126     /* prepare iobufs */
127     if( multifile )  /* have list of filenames */
128         inp = NULL; /* we do it later */
129     else if( !(inp = iobuf_open(fname)) ) {
130         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
131                                         strerror(errno) );
132         rc = G10ERR_OPEN_FILE;
133         goto leave;
134     }
135
136     if( outfile ) {
137         if( !(out = iobuf_create( outfile )) ) {
138             log_error("can't create %s: %s\n", outfile, strerror(errno) );
139             rc = G10ERR_CREATE_FILE;
140             goto leave;
141         }
142         else if( opt.verbose )
143             log_info("writing to '%s'\n", outfile );
144     }
145     else if( !(out = open_outfile( fname, opt.armor? 1: detached? 2:0 )) ) {
146         rc = G10ERR_CREATE_FILE;
147         goto leave;
148     }
149
150     /* prepare to calculate the MD over the input */
151     if( opt.textmode && !outfile )
152         iobuf_push_filter( inp, text_filter, &tfx );
153     mfx.md = md_open(opt.def_digest_algo, 0);
154     if( !multifile )
155         iobuf_push_filter( inp, md_filter, &mfx );
156
157     if( opt.armor && !outfile  )
158         iobuf_push_filter( out, armor_filter, &afx );
159     write_comment( out, "#created by GNUPG v" VERSION " ("
160                                             PRINTABLE_OS_NAME ")");
161     if( opt.compress && !outfile )
162         iobuf_push_filter( out, compress_filter, &zfx );
163
164     if( encrypt ) {
165         efx.pkc_list = pkc_list;
166         /* fixme: set efx.cfx.datalen if known */
167         iobuf_push_filter( out, encrypt_filter, &efx );
168     }
169
170     if( !detached ) {
171         /* loop over the secret certificates and build headers */
172         for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
173             PKT_secret_cert *skc;
174             PKT_onepass_sig *ops;
175
176             skc = skc_rover->skc;
177             ops = m_alloc_clear( sizeof *ops );
178             ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
179             ops->digest_algo = opt.def_digest_algo;
180             ops->pubkey_algo = skc->pubkey_algo;
181             keyid_from_skc( skc, ops->keyid );
182             ops->last = !skc_rover->next;
183
184             init_packet(&pkt);
185             pkt.pkttype = PKT_ONEPASS_SIG;
186             pkt.pkt.onepass_sig = ops;
187             rc = build_packet( out, &pkt );
188             free_packet( &pkt );
189             if( rc ) {
190                 log_error("build onepass_sig packet failed: %s\n",
191                                                         g10_errstr(rc));
192                 goto leave;
193             }
194         }
195     }
196
197
198     /* setup the inner packet */
199     if( detached ) {
200         if( multifile ) {
201             STRLIST sl;
202
203             if( opt.verbose )
204                 log_info("signing:" );
205             /* must walk reverse trough this list */
206             for( sl = strlist_last(filenames); sl;
207                         sl = strlist_prev( filenames, sl ) ) {
208                 if( !(inp = iobuf_open(sl->d)) ) {
209                     log_error("can't open %s: %s\n", sl->d, strerror(errno) );
210                     rc = G10ERR_OPEN_FILE;
211                     goto leave;
212                 }
213                 if( opt.verbose )
214                     fprintf(stderr, " '%s'", sl->d );
215                 iobuf_push_filter( inp, md_filter, &mfx );
216                 while( iobuf_get(inp) != -1 )
217                     ;
218                 iobuf_close(inp); inp = NULL;
219             }
220             if( opt.verbose )
221                 putc( '\n', stderr );
222         }
223         else {
224             /* read, so that the filter can calculate the digest */
225             while( iobuf_get(inp) != -1 )
226                 ;
227         }
228     }
229     else {
230         if( fname ) {
231             pt = m_alloc( sizeof *pt + strlen(fname) - 1 );
232             pt->namelen = strlen(fname);
233             memcpy(pt->name, fname, pt->namelen );
234             if( !(filesize = iobuf_get_filelength(inp)) )
235                 log_info("warning: '%s' is an empty file\n", fname );
236         }
237         else { /* no filename */
238             pt = m_alloc( sizeof *pt - 1 );
239             pt->namelen = 0;
240             filesize = 0; /* stdin */
241         }
242         pt->timestamp = make_timestamp();
243         pt->mode = opt.textmode && !outfile ? 't':'b';
244         pt->len = filesize;
245         pt->buf = inp;
246         pkt.pkttype = PKT_PLAINTEXT;
247         pkt.pkt.plaintext = pt;
248         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
249         if( (rc = build_packet( out, &pkt )) )
250             log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
251         pt->buf = NULL;
252     }
253
254     /* loop over the secret certificates */
255     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
256         PKT_secret_cert *skc;
257         PKT_signature *sig;
258         MD_HANDLE md;
259
260         skc = skc_rover->skc;
261
262         /* build the signature packet */
263         sig = m_alloc_clear( sizeof *sig );
264         sig->pubkey_algo = skc->pubkey_algo;
265         sig->timestamp = make_timestamp();
266         sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
267
268         md = md_copy( mfx.md );
269         md_putc( md, sig->sig_class );
270         {   u32 a = sig->timestamp;
271             md_putc( md, (a >> 24) & 0xff );
272             md_putc( md, (a >> 16) & 0xff );
273             md_putc( md, (a >>  8) & 0xff );
274             md_putc( md,  a        & 0xff );
275         }
276         md_final( md );
277
278         if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
279             g10_elg_sign( skc, sig, md, opt.def_digest_algo );
280         else if( sig->pubkey_algo == PUBKEY_ALGO_DSA )
281             g10_dsa_sign( skc, sig, md, opt.def_digest_algo );
282         else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
283             g10_rsa_sign( skc, sig, md, opt.def_digest_algo );
284         else
285             BUG();
286
287         md_close( md );
288
289         /* and write it */
290         init_packet(&pkt);
291         pkt.pkttype = PKT_SIGNATURE;
292         pkt.pkt.signature = sig;
293         rc = build_packet( out, &pkt );
294         free_packet( &pkt );
295         if( rc ) {
296             log_error("build signature packet failed: %s\n", g10_errstr(rc) );
297             goto leave;
298         }
299     }
300
301
302   leave:
303     if( rc )
304         iobuf_cancel(out);
305     else
306         iobuf_close(out);
307     iobuf_close(inp);
308     md_close( mfx.md );
309     release_skc_list( skc_list );
310     release_pkc_list( pkc_list );
311     return rc;
312 }
313
314
315
316 /****************
317  * note: we do not count empty lines at the beginning
318  */
319 static int
320 write_dash_escaped( IOBUF inp, IOBUF out, MD_HANDLE md )
321 {
322     int c;
323     int lastlf = 1;
324     int skip_empty = 1;
325
326     while( (c = iobuf_get(inp)) != -1 ) {
327         /* Note: We don't escape "From " because the MUA should cope with it */
328         if( lastlf ) {
329             if( c == '-' ) {
330                 iobuf_put( out, c );
331                 iobuf_put( out, ' ' );
332                 skip_empty = 0;
333             }
334             else if( skip_empty && c == '\r' )
335                 skip_empty = 2;
336             else
337                 skip_empty = 0;
338         }
339
340         if( !skip_empty )
341             md_putc(md, c );
342         iobuf_put( out, c );
343         lastlf = c == '\n';
344         if( skip_empty == 2 )
345             skip_empty = lastlf ? 0 : 1;
346     }
347     return 0; /* fixme: add error handling */
348 }
349
350
351 /****************
352  * make a clear signature. note that opt.armor is not needed
353  */
354 int
355 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
356 {
357     armor_filter_context_t afx;
358     compress_filter_context_t zfx;
359     text_filter_context_t tfx;
360     MD_HANDLE textmd = NULL;
361     IOBUF inp = NULL, out = NULL;
362     PACKET pkt;
363     int rc = 0;
364     SKC_LIST skc_list = NULL;
365     SKC_LIST skc_rover = NULL;
366
367     memset( &afx, 0, sizeof afx);
368     memset( &zfx, 0, sizeof zfx);
369     memset( &tfx, 0, sizeof tfx);
370     init_packet( &pkt );
371
372     if( (rc=build_skc_list( locusr, &skc_list, 1, 1 )) )
373         goto leave;
374
375     /* prepare iobufs */
376     if( !(inp = iobuf_open(fname)) ) {
377         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
378                                         strerror(errno) );
379         rc = G10ERR_OPEN_FILE;
380         goto leave;
381     }
382
383     if( outfile ) {
384         if( !(out = iobuf_create( outfile )) ) {
385             log_error("can't create %s: %s\n", outfile, strerror(errno) );
386             rc = G10ERR_CREATE_FILE;
387             goto leave;
388         }
389         else if( opt.verbose )
390             log_info("writing to '%s'\n", outfile );
391     }
392     else if( !(out = open_outfile( fname, 1 )) ) {
393         rc = G10ERR_CREATE_FILE;
394         goto leave;
395     }
396
397     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n"
398                         "Hash: RIPEMD160\n\n" );
399
400     textmd = md_open(opt.def_digest_algo, 0);
401     iobuf_push_filter( inp, text_filter, &tfx );
402     rc = write_dash_escaped( inp, out, textmd );
403     if( rc )
404         goto leave;
405
406     iobuf_writestr(out, "\n" );
407     afx.what = 2;
408     iobuf_push_filter( out, armor_filter, &afx );
409
410     /* loop over the secret certificates */
411     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
412         PKT_secret_cert *skc;
413         PKT_signature *sig;
414         MD_HANDLE md;
415
416         skc = skc_rover->skc;
417
418         /* build the signature packet */
419         sig = m_alloc_clear( sizeof *sig );
420         sig->pubkey_algo = skc->pubkey_algo;
421         sig->timestamp = make_timestamp();
422         sig->sig_class = 0x01;
423
424         md = md_copy( textmd );
425         md_putc( md, sig->sig_class );
426         {   u32 a = sig->timestamp;
427             md_putc( md, (a >> 24) & 0xff );
428             md_putc( md, (a >> 16) & 0xff );
429             md_putc( md, (a >>  8) & 0xff );
430             md_putc( md,  a        & 0xff );
431         }
432         md_final( md );
433
434         if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
435             g10_elg_sign( skc, sig, md, opt.def_digest_algo );
436         else if( sig->pubkey_algo == PUBKEY_ALGO_DSA )
437             g10_dsa_sign( skc, sig, md, opt.def_digest_algo );
438         else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
439             g10_rsa_sign( skc, sig, md, opt.def_digest_algo );
440         else
441             BUG();
442
443         md_close( md );
444
445         /* and write it */
446         init_packet(&pkt);
447         pkt.pkttype = PKT_SIGNATURE;
448         pkt.pkt.signature = sig;
449         rc = build_packet( out, &pkt );
450         free_packet( &pkt );
451         if( rc ) {
452             log_error("build signature packet failed: %s\n", g10_errstr(rc) );
453             goto leave;
454         }
455     }
456
457
458   leave:
459     if( rc )
460         iobuf_cancel(out);
461     else
462         iobuf_close(out);
463     iobuf_close(inp);
464     md_close( textmd );
465     release_skc_list( skc_list );
466     return rc;
467 }
468
469
470
471
472 static void
473 show_fingerprint( PKT_public_cert *pkc )
474 {
475     byte *array, *p;
476     size_t i, n;
477
478     p = array = fingerprint_from_pkc( pkc, &n );
479     tty_printf("             Fingerprint:");
480     if( n == 20 ) {
481         for(i=0; i < n ; i++, i++, p += 2 ) {
482             if( i == 10 )
483                 tty_printf(" ");
484             tty_printf(" %02X%02X", *p, p[1] );
485         }
486     }
487     else {
488         for(i=0; i < n ; i++, p++ ) {
489             if( i && !(i%8) )
490                 tty_printf(" ");
491             tty_printf(" %02X", *p );
492         }
493     }
494     tty_printf("\n");
495     m_free(array);
496 }
497
498
499 /****************
500  * Ask wether the user is willing to sign the key. Return true if so.
501  */
502 static int
503 sign_it_p( PKT_public_cert *pkc, PKT_user_id *uid )
504 {
505     char *answer;
506     int yes;
507
508     tty_printf("\nAre you really sure that you want so sign this key:\n\n"
509                "%4u%c/%08lX %s ",
510               nbits_from_pkc( pkc ),
511               pubkey_letter( pkc->pubkey_algo ),
512               (ulong)keyid_from_pkc( pkc, NULL ),
513               datestr_from_pkc( pkc )               );
514     tty_print_string( uid->name, uid->len );
515     tty_printf("\n");
516     show_fingerprint(pkc);
517     tty_printf("\n");
518     answer = tty_get("Sign this key? ");
519     tty_kill_prompt();
520     yes = answer_is_yes(answer);
521     m_free(answer);
522     return yes;
523 }
524
525
526 /****************
527  * Check the keysigs and set the flags to indicate errors.
528  * Usage of nodes flag bits:
529  * Bit  0 = bad signature
530  *      1 = no public key
531  *      2 = other error
532  * Returns true if error found.
533  */
534 static int
535 check_all_keysigs( KBNODE keyblock )
536 {
537     KBNODE kbctx;
538     KBNODE node;
539     int rc;
540     int inv_sigs = 0;
541     int no_key = 0;
542     int oth_err = 0;
543
544     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
545         if( node->pkt->pkttype == PKT_SIGNATURE
546             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
547             PKT_signature *sig = node->pkt->pkt.signature;
548             int sigrc;
549
550             tty_printf("sig");
551             switch( (rc = check_key_signature( keyblock, node,NULL)) ) {
552               case 0:                node->flag = 0; sigrc = '!'; break;
553               case G10ERR_BAD_SIGN:  inv_sigs++; node->flag = 1; sigrc = '-'; break;
554               case G10ERR_NO_PUBKEY: no_key++;   node->flag = 2; sigrc = '?'; break;
555               default:               oth_err++;  node->flag = 4; sigrc = '%'; break;
556             }
557             tty_printf("%c       %08lX %s   ",
558                     sigrc, sig->keyid[1], datestr_from_sig(sig));
559             if( sigrc == '%' )
560                 tty_printf("[%s] ", g10_errstr(rc) );
561             else if( sigrc == '?' )
562                 ;
563             else {
564                 size_t n;
565                 char *p = get_user_id( sig->keyid, &n );
566                 tty_print_string( p, n > 40? 40 : n );
567                 m_free(p);
568             }
569             tty_printf("\n");
570             /* FIXME: update the trustdb */
571         }
572     }
573     if( inv_sigs )
574         tty_printf("%d bad signatures\n", inv_sigs );
575     if( no_key )
576         tty_printf("No public key for %d signatures\n", no_key );
577     if( oth_err )
578         tty_printf("%d signatures not checked due to errors\n", oth_err );
579     return inv_sigs || no_key || oth_err;
580 }
581
582
583 /****************
584  * Ask and remove invalid signatures are to be removed.
585  */
586 static int
587 remove_keysigs( KBNODE keyblock, u32 *keyid, int all )
588 {
589     KBNODE kbctx;
590     KBNODE node;
591     char *answer;
592     int yes;
593     int count;
594
595     count = 0;
596     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
597         if( ((node->flag & 7) || all )
598             && node->pkt->pkttype == PKT_SIGNATURE
599             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
600             PKT_signature *sig = node->pkt->pkt.signature;
601
602             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
603                 /* fixme: skip self-sig */
604             }
605
606             tty_printf("\n \"%08lX %s   ",
607                         sig->keyid[1], datestr_from_sig(sig));
608             if( node->flag & 6 )
609                 tty_printf("[User name not available] ");
610             else {
611                 size_t n;
612                 char *p = get_user_id( sig->keyid, &n );
613                 tty_print_string( p, n );
614                 m_free(p);
615             }
616             tty_printf("\"\n");
617             if( node->flag & 1 )
618                 tty_printf("This is a BAD signature!\n");
619             else if( node->flag & 2 )
620                 tty_printf("Public key not available.\n");
621             else if( node->flag & 4 )
622                 tty_printf("The signature could not be checked!\n");
623
624             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
625                 continue; /* do not remove self-signatures */
626
627             answer = tty_get("\nRemove this signature? ");
628             tty_kill_prompt();
629             if( answer_is_yes(answer) ) {
630                 node->flag |= 128;     /* use bit 7 to mark this node */
631                 count++;
632             }
633             m_free(answer);
634         }
635     }
636
637     if( !count )
638         return 0; /* nothing to remove */
639     answer = tty_get("Do you really want to remove the selected signatures? ");
640     tty_kill_prompt();
641     yes = answer_is_yes(answer);
642     m_free(answer);
643     if( !yes )
644         return 0;
645
646     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 1)) ; ) {
647         if( node->flag & 128)
648             delete_kbnode(node );
649     }
650
651     return 1;
652 }
653
654
655 /****************
656  * This functions signs the key of USERNAME with all users listed in
657  * LOCUSR. If LOCUSR is NULL the default secret certificate will
658  * be used.  This works on all keyrings, so there is no armor or
659  * compress stuff here.
660  */
661 int
662 sign_key( const char *username, STRLIST locusr )
663 {
664     md_filter_context_t mfx;
665     int rc = 0;
666     SKC_LIST skc_list = NULL;
667     SKC_LIST skc_rover = NULL;
668     KBNODE keyblock = NULL;
669     KBNODE kbctx, node;
670     KBPOS kbpos;
671     PKT_public_cert *pkc;
672     u32 pkc_keyid[2];
673     char *answer;
674
675     memset( &mfx, 0, sizeof mfx);
676
677     /* search the userid */
678     rc = find_keyblock_byname( &kbpos, username );
679     if( rc ) {
680         log_error("user '%s' not found\n", username );
681         goto leave;
682     }
683
684     /* build a list of all signators */
685     rc=build_skc_list( locusr, &skc_list, 0, 1 );
686     if( rc )
687         goto leave;
688
689
690     /* read the keyblock */
691     rc = read_keyblock( &kbpos, &keyblock );
692     if( rc ) {
693         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
694         goto leave;
695     }
696
697     /* get the keyid from the keyblock */
698     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
699     if( !node ) {
700         log_error("Oops; public key not found anymore!\n");
701         rc = G10ERR_GENERAL;
702         goto leave;
703     }
704
705     pkc = node->pkt->pkt.public_cert;
706     keyid_from_pkc( pkc, pkc_keyid );
707     log_info("Checking signatures of this public key certificate:\n");
708     tty_printf("pub  %4u%c/%08lX %s   ",
709               nbits_from_pkc( pkc ),
710               pubkey_letter( pkc->pubkey_algo ),
711               pkc_keyid[1], datestr_from_pkc(pkc) );
712     {
713         size_t n;
714         char *p = get_user_id( pkc_keyid, &n );
715         tty_print_string( p, n > 40? 40 : n );
716         m_free(p);
717         tty_printf("\n");
718     }
719
720     clear_kbnode_flags( keyblock );
721     if( check_all_keysigs( keyblock ) ) {
722         if( !opt.batch ) {
723             /* ask wether we really should do anything */
724             answer = tty_get("To you want to remove some of the invalid sigs? ");
725             tty_kill_prompt();
726             if( answer_is_yes(answer) )
727                 remove_keysigs( keyblock, pkc_keyid, 0 );
728             m_free(answer);
729         }
730     }
731
732     /* check wether we have already signed it */
733     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
734         u32 akeyid[2];
735
736         keyid_from_skc( skc_rover->skc, akeyid );
737         for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
738             if( node->pkt->pkttype == PKT_SIGNATURE
739                 && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
740                 if( akeyid[0] == node->pkt->pkt.signature->keyid[0]
741                     && akeyid[1] == node->pkt->pkt.signature->keyid[1] ) {
742                     log_info("Already signed by keyid %08lX\n",
743                                                         (ulong)akeyid[1] );
744                     skc_rover->mark = 1;
745                 }
746             }
747         }
748     }
749     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
750         if( !skc_rover->mark )
751             break;
752     }
753     if( !skc_rover ) {
754         log_info("Nothing to sign\n");
755         goto leave;
756     }
757
758     /* Loop over all signers and all user ids and sign */
759     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
760         if( skc_rover->mark )
761             continue;
762         for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
763             if( node->pkt->pkttype == PKT_USER_ID ) {
764                 if( sign_it_p( pkc, node->pkt->pkt.user_id ) ) {
765                     PACKET *pkt;
766                     PKT_signature *sig;
767
768                     rc = make_keysig_packet( &sig, pkc,
769                                                    node->pkt->pkt.user_id,
770                                                    skc_rover->skc,
771                                                    0x10,
772                                                    DIGEST_ALGO_RMD160 );
773                     if( rc ) {
774                         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc));
775                         goto leave;
776                     }
777
778                     pkt = m_alloc_clear( sizeof *pkt );
779                     pkt->pkttype = PKT_SIGNATURE;
780                     pkt->pkt.signature = sig;
781                     insert_kbnode( node, new_kbnode(pkt), PKT_USER_ID );
782                 }
783             }
784         }
785     }
786
787     rc = update_keyblock( &kbpos, keyblock );
788     if( rc ) {
789         log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
790         goto leave;
791     }
792
793   leave:
794     release_kbnode( keyblock );
795     release_skc_list( skc_list );
796     md_close( mfx.md );
797     return rc;
798 }
799
800
801
802 int
803 edit_keysigs( const char *username )
804 {
805     int rc = 0;
806     KBNODE keyblock = NULL;
807     KBNODE node;
808     KBPOS kbpos;
809     PKT_public_cert *pkc;
810     u32 pkc_keyid[2];
811
812     /* search the userid */
813     rc = find_keyblock_byname( &kbpos, username );
814     if( rc ) {
815         log_error("%s: user not found\n", username );
816         goto leave;
817     }
818
819     /* read the keyblock */
820     rc = read_keyblock( &kbpos, &keyblock );
821     if( rc ) {
822         log_error("%s: certificate read problem: %s\n", username, g10_errstr(rc) );
823         goto leave;
824     }
825
826     /* get the keyid from the keyblock */
827     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
828     if( !node ) {
829         log_error("Oops; public key not found anymore!\n");
830         rc = G10ERR_GENERAL;
831         goto leave;
832     }
833
834     pkc = node->pkt->pkt.public_cert;
835     keyid_from_pkc( pkc, pkc_keyid );
836     log_info("Checking signatures of this public key certificate:\n");
837     tty_printf("pub  %4u%c/%08lX %s   ",
838               nbits_from_pkc( pkc ),
839               pubkey_letter( pkc->pubkey_algo ),
840               pkc_keyid[1], datestr_from_pkc(pkc) );
841     {
842         size_t n;
843         char *p = get_user_id( pkc_keyid, &n );
844         tty_print_string( p, n > 40? 40 : n );
845         m_free(p);
846         tty_printf("\n");
847     }
848
849     clear_kbnode_flags( keyblock );
850     check_all_keysigs( keyblock );
851     if( remove_keysigs( keyblock, pkc_keyid, 1 ) ) {
852         rc = update_keyblock( &kbpos, keyblock );
853         if( rc ) {
854             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
855             goto leave;
856         }
857     }
858
859   leave:
860     release_kbnode( keyblock );
861     return rc;
862 }
863
864
865 /****************
866  * Delete a public or secret key from a keyring.
867  */
868 int
869 delete_key( const char *username, int secret )
870 {
871     int rc = 0;
872     KBNODE keyblock = NULL;
873     KBNODE node;
874     KBPOS kbpos;
875     PKT_public_cert *pkc = NULL;
876     PKT_secret_cert *skc = NULL;
877     u32 keyid[2];
878     int okay=0;
879
880     /* search the userid */
881     rc = secret? find_secret_keyblock_byname( &kbpos, username )
882                : find_keyblock_byname( &kbpos, username );
883     if( rc ) {
884         log_error("%s: user not found\n", username );
885         goto leave;
886     }
887
888     /* read the keyblock */
889     rc = read_keyblock( &kbpos, &keyblock );
890     if( rc ) {
891         log_error("%s: read problem: %s\n", username, g10_errstr(rc) );
892         goto leave;
893     }
894
895     /* get the keyid from the keyblock */
896     node = find_kbnode( keyblock, secret? PKT_SECRET_CERT:PKT_PUBLIC_CERT );
897     if( !node ) {
898         log_error("Oops; key not found anymore!\n");
899         rc = G10ERR_GENERAL;
900         goto leave;
901     }
902
903     if( secret ) {
904         skc = node->pkt->pkt.secret_cert;
905         keyid_from_skc( skc, keyid );
906     }
907     else {
908         pkc = node->pkt->pkt.public_cert;
909         keyid_from_pkc( pkc, keyid );
910         rc = seckey_available( keyid );
911         if( !rc ) {
912             log_error(_(
913             "there is a secret key for this public key!\n"));
914             log_info(_(
915             "use option \"--delete-secret-key\" to delete it first.\n"));
916             rc = -1;
917         }
918         else if( rc != G10ERR_NO_SECKEY )
919             log_error("%s: get secret key: %s\n", username, g10_errstr(rc) );
920         else
921             rc = 0;
922     }
923
924     if( rc )
925         rc = 0;
926     else if( opt.batch && secret )
927         log_error(_("can't do that in batch-mode\n"));
928     else if( opt.batch && opt.answer_yes )
929         okay++;
930     else if( opt.batch )
931         log_error(_("can't do that in batch-mode without \"--yes\"\n"));
932     else {
933         char *p;
934         size_t n;
935
936         if( secret )
937             tty_printf("sec  %4u%c/%08lX %s   ",
938                       nbits_from_skc( skc ),
939                       pubkey_letter( skc->pubkey_algo ),
940                       keyid[1], datestr_from_skc(skc) );
941         else
942             tty_printf("pub  %4u%c/%08lX %s   ",
943                       nbits_from_pkc( pkc ),
944                       pubkey_letter( pkc->pubkey_algo ),
945                       keyid[1], datestr_from_pkc(pkc) );
946         p = get_user_id( keyid, &n );
947         tty_print_string( p, n );
948         m_free(p);
949         tty_printf("\n\n");
950
951         p = tty_get(_("Delete this key from the keyring? "));
952         tty_kill_prompt();
953         if( secret && answer_is_yes(p)) {
954             /* I think it is not required to check a passphrase; if
955              * the user is so stupid to let others access his secret keyring
956              * (and has no backup) - it is up him to read some very
957              * basic texts about security.
958              */
959             m_free(p);
960             p = tty_get(_("This is a secret key! - really delete? "));
961         }
962         if( answer_is_yes(p) )
963             okay++;
964         m_free(p);
965     }
966
967
968     if( okay ) {
969         rc = delete_keyblock( &kbpos );
970         if( rc ) {
971             log_error("delete_keyblock failed: %s\n", g10_errstr(rc) );
972             goto leave;
973         }
974     }
975
976   leave:
977     release_kbnode( keyblock );
978     return rc;
979 }
980
981
982 int
983 change_passphrase( const char *username )
984 {
985     int rc = 0;
986     KBNODE keyblock = NULL;
987     KBNODE node;
988     KBPOS kbpos;
989     PKT_secret_cert *skc;
990     u32 skc_keyid[2];
991     char *answer;
992     int changed=0;
993
994     /* search the userid */
995     rc = find_secret_keyblock_byname( &kbpos, username );
996     if( rc ) {
997         log_error("secret key for user '%s' not found\n", username );
998         goto leave;
999     }
1000
1001     /* read the keyblock */
1002     rc = read_keyblock( &kbpos, &keyblock );
1003     if( rc ) {
1004         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
1005         goto leave;
1006     }
1007
1008     /* get the keyid from the keyblock */
1009     node = find_kbnode( keyblock, PKT_SECRET_CERT );
1010     if( !node ) {
1011         log_error("Oops; secret key not found anymore!\n");
1012         rc = G10ERR_GENERAL;
1013         goto leave;
1014     }
1015
1016     skc = node->pkt->pkt.secret_cert;
1017     keyid_from_skc( skc, skc_keyid );
1018     tty_printf("sec  %4u%c/%08lX %s   ",
1019               nbits_from_skc( skc ),
1020               pubkey_letter( skc->pubkey_algo ),
1021               skc_keyid[1], datestr_from_skc(skc) );
1022     {
1023         size_t n;
1024         char *p = get_user_id( skc_keyid, &n );
1025         tty_print_string( p, n );
1026         m_free(p);
1027         tty_printf("\n");
1028     }
1029
1030     clear_kbnode_flags( keyblock );
1031     switch( is_secret_key_protected( skc ) ) {
1032       case -1:
1033         rc = G10ERR_PUBKEY_ALGO;
1034         break;
1035       case 0:
1036         tty_printf("This key is not protected.\n");
1037         break;
1038       default:
1039         tty_printf("Key is protected.\n");
1040         rc = check_secret_key( skc );
1041         break;
1042     }
1043
1044     if( rc )
1045         tty_printf("Can't edit this key: %s\n", g10_errstr(rc));
1046     else {
1047         DEK *dek = m_alloc_secure( sizeof *dek + 8 );
1048         byte *salt = (byte*)dek + sizeof( *dek );
1049
1050         tty_printf( "Enter the new passphrase for this secret key.\n\n" );
1051
1052         for(;;) {
1053             dek->algo = CIPHER_ALGO_BLOWFISH;
1054             randomize_buffer(salt, 8, 1);
1055             rc = make_dek_from_passphrase( dek , 2, salt );
1056             if( rc == -1 ) {
1057                 rc = 0;
1058                 tty_printf( "You don't want a passphrase -"
1059                             " this is probably a *bad* idea!\n\n");
1060                 answer = tty_get("Do you really want to do this? ");
1061                 tty_kill_prompt();
1062                 if( answer_is_yes(answer) )
1063                     changed++;
1064                 m_free(answer);
1065                 break;
1066             }
1067             else if( rc == G10ERR_PASSPHRASE ) {
1068                 tty_printf("passphrase not correctly repeated; try again.\n");
1069             }
1070             else if( rc ) {
1071                 m_free(dek); dek = NULL;
1072                 log_error("Error getting the passphrase: %s\n", g10_errstr(rc));
1073                 break;
1074             }
1075             else { /* okay */
1076                 skc->protect.algo = CIPHER_ALGO_BLOWFISH;
1077                 skc->protect.s2k  = 1;
1078                 skc->protect.hash = DIGEST_ALGO_RMD160;
1079                 memcpy(skc->protect.salt, salt, 8);
1080                 randomize_buffer(skc->protect.iv, 8, 1);
1081                 rc = protect_secret_key( skc, dek );
1082                 if( rc )
1083                     log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
1084                 else
1085                     changed++;
1086                 break;
1087             }
1088         }
1089         m_free(dek);
1090     }
1091
1092
1093     if( changed ) {
1094         rc = update_keyblock( &kbpos, keyblock );
1095         if( rc ) {
1096             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
1097             goto leave;
1098         }
1099     }
1100
1101   leave:
1102     release_kbnode( keyblock );
1103     return rc;
1104 }
1105
1106
1107 /****************
1108  * Create a signature packet for the given public key certificate
1109  * and the user id and return it in ret_sig. User signature class SIGCLASS
1110  * user-id is not used (and may be NULL if sigclass is 0x20)
1111  */
1112 int
1113 make_keysig_packet( PKT_signature **ret_sig, PKT_public_cert *pkc,
1114                     PKT_user_id *uid, PKT_secret_cert *skc,
1115                     int sigclass, int digest_algo )
1116 {
1117     PKT_signature *sig;
1118     int rc=0;
1119     MD_HANDLE md;
1120
1121     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x20 );
1122     md = md_open( digest_algo, 0 );
1123
1124     /* hash the public key certificate and the user id */
1125     hash_public_cert( md, pkc );
1126     if( sigclass != 0x20 )
1127         md_write( md, uid->name, uid->len );
1128     /* and make the signature packet */
1129     sig = m_alloc_clear( sizeof *sig );
1130     sig->pubkey_algo = skc->pubkey_algo;
1131     sig->timestamp = make_timestamp();
1132     sig->sig_class = sigclass;
1133
1134     md_putc( md, sig->sig_class );
1135     {   u32 a = sig->timestamp;
1136         md_putc( md, (a >> 24) & 0xff );
1137         md_putc( md, (a >> 16) & 0xff );
1138         md_putc( md, (a >>  8) & 0xff );
1139         md_putc( md,  a        & 0xff );
1140     }
1141     md_final(md);
1142
1143     rc = complete_sig( sig, skc, md );
1144
1145     md_close( md );
1146     if( rc )
1147         free_seckey_enc( sig );
1148     else
1149         *ret_sig = sig;
1150     return rc;
1151 }
1152