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