a8541391d81354e6aa51fec47466039ae9293008
[gnupg.git] / g10 / sign.c
1 /* sign.c - sign data
2  *      Copyright (c) 1997 by Werner Koch (dd9jn)
3  *
4  * This file is part of G10.
5  *
6  * G10 is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * G10 is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "iobuf.h"
32 #include "keydb.h"
33 #include "memory.h"
34 #include "util.h"
35 #include "main.h"
36 #include "filter.h"
37 #include "ttyio.h"
38
39
40
41
42
43 static int
44 complete_sig( PKT_signature *sig, PKT_secret_cert *skc, MD_HANDLE *md )
45 {
46     int rc=0;
47
48     if( (rc=check_secret_key( skc )) )
49         ;
50     else if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
51         g10_elg_sign( skc, sig, md );
52     else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
53         g10_rsa_sign( skc, sig, md );
54     else
55         log_bug(NULL);
56
57     /* fixme: should we check wether the signature is okay? */
58
59     return rc;
60 }
61
62
63
64
65
66 /****************
67  * Sign the file with name FILENAME.  If DETACHED has the value true,
68  * make a detached signature.  If FILENAME is NULL read from stdin
69  * and ignore the detached mode.  Sign the file with all secret keys
70  * which can be taken from LOCUSR, if this is NULL, use the default one
71  * If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
72  * signed data for these users.
73  */
74 int
75 sign_file( const char *filename, int detached, STRLIST locusr,
76            int encrypt, STRLIST remusr )
77 {
78     armor_filter_context_t afx;
79     compress_filter_context_t zfx;
80     md_filter_context_t mfx;
81     text_filter_context_t tfx;
82     encrypt_filter_context_t efx;
83     IOBUF inp = NULL, out = NULL;
84     PACKET pkt;
85     PKT_plaintext *pt = NULL;
86     u32 filesize;
87     int last_rc, rc = 0;
88     PKC_LIST pkc_list = NULL;
89     SKC_LIST skc_list = NULL;
90     SKC_LIST skc_rover = NULL;
91
92     memset( &afx, 0, sizeof afx);
93     memset( &zfx, 0, sizeof zfx);
94     memset( &mfx, 0, sizeof mfx);
95     memset( &tfx, 0, sizeof tfx);
96     memset( &efx, 0, sizeof efx);
97     init_packet( &pkt );
98
99     if( (rc=build_skc_list( locusr, &skc_list, 1 )) )
100         goto leave;
101     if( encrypt ) {
102         if( (rc=build_pkc_list( remusr, &pkc_list )) )
103             goto leave;
104     }
105
106     /* prepare iobufs */
107     if( !(inp = iobuf_open(filename)) ) {
108         log_error("can't open %s: %s\n", filename? filename: "[stdin]",
109                                         strerror(errno) );
110         rc = G10ERR_OPEN_FILE;
111         goto leave;
112     }
113
114     if( !(out = open_outfile( filename, opt.armor? 1: detached? 2:0 )) ) {
115         rc = G10ERR_CREATE_FILE;
116         goto leave;
117     }
118
119     /* prepare to calculate the MD over the input */
120     if( opt.textmode && opt.armor )
121         iobuf_push_filter( inp, text_filter, &tfx );
122     mfx.rmd160 = rmd160_open(0);
123     iobuf_push_filter( inp, md_filter, &mfx );
124
125     if( opt.armor )
126         iobuf_push_filter( out, armor_filter, &afx );
127     write_comment( out, "#Created by G10 pre-release " VERSION );
128     if( opt.compress )
129         iobuf_push_filter( out, compress_filter, &zfx );
130
131     if( encrypt ) {
132         efx.pkc_list = pkc_list;
133         /* fixme: set efx.cfx.datalen if known */
134         iobuf_push_filter( out, encrypt_filter, &efx );
135     }
136
137     /* loop over the secret certificates and build headers */
138     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
139         PKT_secret_cert *skc;
140         PKT_onepass_sig *ops;
141
142         skc = skc_rover->skc;
143         ops = m_alloc_clear( sizeof *ops );
144         ops->sig_class = opt.textmode? 0x01 : 0x00;
145         ops->digest_algo = DIGEST_ALGO_RMD160;
146         ops->pubkey_algo = skc->pubkey_algo;
147         keyid_from_skc( skc, ops->keyid );
148         ops->last = !skc_rover->next;
149
150         init_packet(&pkt);
151         pkt.pkttype = PKT_ONEPASS_SIG;
152         pkt.pkt.onepass_sig = ops;
153         rc = build_packet( out, &pkt );
154         free_packet( &pkt );
155         if( rc ) {
156             log_error("build onepass_sig packet failed: %s\n", g10_errstr(rc));
157             goto leave;
158         }
159     }
160
161
162     /* setup the inner packet */
163     if( detached ) {
164         /* read, so that the filter can calculate the digest */
165         while( iobuf_get(inp) != -1 )
166             ;
167     }
168     else {
169         if( filename ) {
170             pt = m_alloc( sizeof *pt + strlen(filename) - 1 );
171             pt->namelen = strlen(filename);
172             memcpy(pt->name, filename, pt->namelen );
173             if( !(filesize = iobuf_get_filelength(inp)) )
174                 log_info("warning: '%s' is an empty file\n", filename );
175         }
176         else { /* no filename */
177             pt = m_alloc( sizeof *pt - 1 );
178             pt->namelen = 0;
179             filesize = 0; /* stdin */
180         }
181         pt->timestamp = make_timestamp();
182         pt->mode = opt.textmode? 't':'b';
183         pt->len = filesize;
184         pt->buf = inp;
185         pkt.pkttype = PKT_PLAINTEXT;
186         pkt.pkt.plaintext = pt;
187         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
188         if( (rc = build_packet( out, &pkt )) )
189             log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
190         pt->buf = NULL;
191     }
192
193     /* loop over the secret certificates */
194     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
195         PKT_secret_cert *skc;
196         PKT_signature *sig;
197         RMDHANDLE rmd;
198         byte *dp;
199
200         skc = skc_rover->skc;
201
202         /* build the signature packet */
203         sig = m_alloc_clear( sizeof *sig );
204         sig->pubkey_algo = skc->pubkey_algo;
205         sig->timestamp = make_timestamp();
206         sig->sig_class = opt.textmode? 0x01 : 0x00;
207
208         rmd = rmd160_copy( mfx.rmd160 );
209         rmd160_putchar( rmd, sig->sig_class );
210         {   u32 a = sig->timestamp;
211             rmd160_putchar( rmd, (a >> 24) & 0xff );
212             rmd160_putchar( rmd, (a >> 16) & 0xff );
213             rmd160_putchar( rmd, (a >>  8) & 0xff );
214             rmd160_putchar( rmd,  a        & 0xff );
215         }
216         dp = rmd160_final( rmd );
217
218         if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
219             ELG_secret_key skey;
220             MPI frame;
221
222             keyid_from_skc( skc, sig->keyid );
223             sig->d.elg.digest_algo = DIGEST_ALGO_RMD160;
224             sig->d.elg.digest_start[0] = dp[0];
225             sig->d.elg.digest_start[1] = dp[1];
226             sig->d.elg.a = mpi_alloc( mpi_get_nlimbs(skc->d.elg.p) );
227             sig->d.elg.b = mpi_alloc( mpi_get_nlimbs(skc->d.elg.p) );
228             frame = encode_rmd160_value( dp, 20, mpi_get_nbits(skc->d.elg.p) );
229             skey.p = skc->d.elg.p;
230             skey.g = skc->d.elg.g;
231             skey.y = skc->d.elg.y;
232             skey.x = skc->d.elg.x;
233             elg_sign( sig->d.elg.a, sig->d.elg.b, frame, &skey);
234             memset( &skey, 0, sizeof skey );
235             mpi_free(frame);
236             if( opt.verbose ) {
237                 char *ustr = get_user_id_string( sig->keyid );
238                 log_info("ELG signature from: %s\n", ustr );
239                 m_free(ustr);
240             }
241         }
242       #ifdef HAVE_RSA_CIPHER
243         else if( sig->pubkey_algo == PUBKEY_ALGO_RSA ) {
244             RSA_secret_key skey;
245
246             keyid_from_skc( skc, sig->keyid );
247             sig->d.rsa.digest_algo = DIGEST_ALGO_RMD160;
248             sig->d.rsa.digest_start[0] = dp[0];
249             sig->d.rsa.digest_start[1] = dp[1];
250             sig->d.rsa.rsa_integer = encode_rmd160_value( dp, 20,
251                                             mpi_get_nbits(skc->d.rsa.rsa_n) );
252             skey.e = skc->d.rsa.rsa_e;
253             skey.n = skc->d.rsa.rsa_n;
254             skey.p = skc->d.rsa.rsa_p;
255             skey.q = skc->d.rsa.rsa_q;
256             skey.d = skc->d.rsa.rsa_d;
257             skey.u = skc->d.rsa.rsa_u;
258             rsa_secret( sig->d.rsa.rsa_integer, sig->d.rsa.rsa_integer, &skey);
259             memset( &skey, 0, sizeof skey );
260             if( opt.verbose ) {
261                 char *ustr = get_user_id_string( sig->keyid );
262                 log_info("RSA signature from: %s\n", ustr );
263                 m_free(ustr);
264             }
265             /* fixme: should we check wether the signature is okay? */
266         }
267       #endif/*HAVE_RSA_CIPHER*/
268         else
269             log_bug(NULL);
270
271         rmd160_close( rmd );
272
273         /* and write it */
274         init_packet(&pkt);
275         pkt.pkttype = PKT_SIGNATURE;
276         pkt.pkt.signature = sig;
277         rc = build_packet( out, &pkt );
278         free_packet( &pkt );
279         if( rc ) {
280             log_error("build signature packet failed: %s\n", g10_errstr(rc) );
281             goto leave;
282         }
283     }
284
285
286   leave:
287     if( rc )
288         iobuf_cancel(out);
289     else
290         iobuf_close(out);
291     iobuf_close(inp);
292     rmd160_close( mfx.rmd160 );
293     release_skc_list( skc_list );
294     release_pkc_list( pkc_list );
295     return rc;
296 }
297
298
299
300 static void
301 show_fingerprint( PKT_public_cert *pkc )
302 {
303     byte *array, *p;
304     size_t i, n;
305
306     p = array = fingerprint_from_pkc( pkc, &n );
307     tty_printf("             Fingerprint:");
308     if( n == 20 ) {
309         for(i=0; i < n ; i++, i++, p += 2 ) {
310             if( i == 10 )
311                 tty_printf(" ");
312             tty_printf(" %02X%02X", *p, p[1] );
313         }
314     }
315     else {
316         for(i=0; i < n ; i++, p++ ) {
317             if( i && !(i%8) )
318                 tty_printf(" ");
319             tty_printf(" %02X", *p );
320         }
321     }
322     tty_printf("\n");
323     m_free(array);
324 }
325
326
327 /****************
328  * Ask wether the user is willing to sign the key. Return true if so.
329  */
330 static int
331 sign_it_p( PKT_public_cert *pkc, PKT_user_id *uid )
332 {
333     char *answer;
334     int yes;
335
336     tty_printf("\nAre you really sure that you want so sign this key:\n\n"
337                "%4u%c/%08lX %s ",
338               nbits_from_pkc( pkc ),
339               pubkey_letter( pkc->pubkey_algo ),
340               (ulong)keyid_from_pkc( pkc, NULL ),
341               datestr_from_pkc( pkc )               );
342     tty_print_string( uid->name, uid->len );
343     tty_printf("\n");
344     show_fingerprint(pkc);
345     tty_printf("\n");
346     answer = tty_get("Sign this key? ");
347     tty_kill_prompt();
348     yes = answer_is_yes(answer);
349     m_free(answer);
350     return yes;
351 }
352
353
354 /****************
355  * Check the keysigs and set the flags to indicate errors.
356  * Usage of nodes flag bits:
357  * Bit  0 = bad signature
358  *      1 = no public key
359  *      2 = other error
360  * Returns true if error found.
361  */
362 static int
363 check_all_keysigs( KBNODE keyblock )
364 {
365     KBNODE kbctx;
366     KBNODE node;
367     int rc;
368     int inv_sigs = 0;
369     int no_key = 0;
370     int oth_err = 0;
371
372     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
373         if( node->pkt->pkttype == PKT_SIGNATURE
374             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
375             PKT_signature *sig = node->pkt->pkt.signature;
376             int sigrc;
377
378             tty_printf("sig");
379             switch( (rc = check_key_signature( keyblock, node )) ) {
380               case 0:                node->flag = 0; sigrc = '!'; break;
381               case G10ERR_BAD_SIGN:  inv_sigs++; node->flag = 1; sigrc = '-'; break;
382               case G10ERR_NO_PUBKEY: no_key++;   node->flag = 2; sigrc = '?'; break;
383               default:               oth_err++;  node->flag = 4; sigrc = '%'; break;
384             }
385             tty_printf("%c       %08lX %s   ",
386                     sigrc, sig->keyid[1], datestr_from_sig(sig));
387             if( sigrc == '%' )
388                 tty_printf("[%s] ", g10_errstr(rc) );
389             else if( sigrc == '?' )
390                 ;
391             else {
392                 size_t n;
393                 char *p = get_user_id( sig->keyid, &n );
394                 tty_print_string( p, n > 40? 40 : n );
395                 m_free(p);
396             }
397             tty_printf("\n");
398             /* FIXME: update the trustdb */
399         }
400     }
401     if( inv_sigs )
402         tty_printf("%d bad signatures\n", inv_sigs );
403     if( no_key )
404         tty_printf("No public key for %d signatures\n", no_key );
405     if( oth_err )
406         tty_printf("%d signatures not checked due to errors\n", oth_err );
407     return inv_sigs || no_key || oth_err;
408 }
409
410
411 /****************
412  * Ask and remove invalid signatures are to be removed.
413  */
414 static int
415 remove_keysigs( KBNODE keyblock, int all )
416 {
417     KBNODE kbctx;
418     KBNODE node;
419     char *answer;
420     int yes;
421     int count;
422
423     count = 0;
424     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
425         if( ((node->flag & 7) || all )
426             && node->pkt->pkttype == PKT_SIGNATURE
427             && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
428             PKT_signature *sig = node->pkt->pkt.signature;
429             int sigrc;
430
431             if( all ) {
432                 /* fixme: skip self-sig */
433             }
434
435             tty_printf("\n \"%08lX %s   ",
436                         sig->keyid[1], datestr_from_sig(sig));
437             if( node->flag & 6 )
438                 tty_printf("[User name not available] ");
439             else {
440                 size_t n;
441                 char *p = get_user_id( sig->keyid, &n );
442                 tty_print_string( p, n );
443                 m_free(p);
444             }
445             tty_printf("\"\n");
446             if( node->flag & 1 )
447                 tty_printf("This is a BAD signature!\n");
448             else if( node->flag & 2 )
449                 tty_printf("Public key not available.\n");
450             else if( node->flag & 4 )
451                 tty_printf("The signature could not be checked!\n");
452             answer = tty_get("\nRemove this signature? ");
453             tty_kill_prompt();
454             if( answer_is_yes(answer) ) {
455                 node->flag |= 128;     /* use bit 7 to mark this node */
456                 count++;
457             }
458             m_free(answer);
459         }
460     }
461
462     if( !count )
463         return 0; /* nothing to remove */
464     answer = tty_get("Do you really want to remove the selected signatures? ");
465     tty_kill_prompt();
466     yes = answer_is_yes(answer);
467     m_free(answer);
468     if( !yes )
469         return 0;
470
471     for( kbctx=NULL; (node=walk_kbtree2( keyblock, &kbctx, 1)) ; ) {
472         if( node->flag & 128)
473             delete_kbnode( keyblock, node );
474     }
475
476     return 1;
477 }
478
479
480 /****************
481  * This functions signs the key of USERNAME with all users listed in
482  * LOCUSR. If LOCUSR is NULL the default secret certificate will
483  * be used.  This works on all keyrings, so there is no armor or
484  * compress stuff here.
485  */
486 int
487 sign_key( const char *username, STRLIST locusr )
488 {
489     md_filter_context_t mfx;
490     int rc = 0;
491     SKC_LIST skc_list = NULL;
492     SKC_LIST skc_rover = NULL;
493     KBNODE keyblock = NULL;
494     KBNODE kbctx, node;
495     KBPOS kbpos;
496     PKT_public_cert *pkc;
497     int any;
498     u32 pkc_keyid[2];
499     char *answer;
500
501     memset( &mfx, 0, sizeof mfx);
502
503     /* search the userid */
504     rc = search_keyblock_byname( &kbpos, username );
505     if( rc ) {
506         log_error("user '%s' not found\n", username );
507         goto leave;
508     }
509
510     /* build a list of all signators */
511     rc=build_skc_list( locusr, &skc_list, 0 );
512     if( rc )
513         goto leave;
514
515
516     /* read the keyblock */
517     rc = read_keyblock( &kbpos, &keyblock );
518     if( rc ) {
519         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
520         goto leave;
521     }
522
523     /* get the keyid from the keyblock */
524     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
525         if( node->pkt->pkttype == PKT_PUBLIC_CERT )
526             break;
527     }
528     if( !node ) {
529         log_error("Oops; public key not found anymore!\n");
530         rc = G10ERR_GENERAL;
531         goto leave;
532     }
533
534     pkc = node->pkt->pkt.public_cert;
535     keyid_from_pkc( pkc, pkc_keyid );
536     log_info("Checking signatures of this public key certificate:\n");
537     tty_printf("pub  %4u%c/%08lX %s   ",
538               nbits_from_pkc( pkc ),
539               pubkey_letter( pkc->pubkey_algo ),
540               pkc_keyid[1], datestr_from_pkc(pkc) );
541     {
542         size_t n;
543         char *p = get_user_id( pkc_keyid, &n );
544         tty_print_string( p, n > 40? 40 : n );
545         m_free(p);
546         tty_printf("\n");
547     }
548
549     clear_kbnode_flags( keyblock );
550     if( check_all_keysigs( keyblock ) ) {
551         if( !opt.batch ) {
552             /* ask wether we really should do anything */
553             answer = tty_get("To you want to remove some of the invalid sigs? ");
554             tty_kill_prompt();
555             if( answer_is_yes(answer) )
556                 remove_keysigs( keyblock, 0 );
557             m_free(answer);
558         }
559     }
560
561     /* check wether we have already signed it */
562     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
563         u32 akeyid[2];
564
565         keyid_from_skc( skc_rover->skc, akeyid );
566         for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
567             if( node->pkt->pkttype == PKT_SIGNATURE
568                 && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
569                 if( akeyid[0] == node->pkt->pkt.signature->keyid[0]
570                     && akeyid[1] == node->pkt->pkt.signature->keyid[1] ) {
571                     log_info("Already signed by keyid %08lX\n", akeyid[1] );
572                     skc_rover->mark = 1;
573                 }
574             }
575         }
576     }
577     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
578         if( !skc_rover->mark )
579             break;
580     }
581     if( !skc_rover ) {
582         log_info("Nothing to sign\n");
583         goto leave;
584     }
585
586     /* Loop over all signers and all user ids and sign */
587     for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
588         if( skc_rover->mark )
589             continue;
590         for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
591             if( node->pkt->pkttype == PKT_USER_ID ) {
592                 if( sign_it_p( pkc, node->pkt->pkt.user_id ) ) {
593                     PACKET *pkt;
594                     PKT_signature *sig;
595
596                     rc = make_keysig_packet( &sig, pkc,
597                                                    node->pkt->pkt.user_id,
598                                                    skc_rover->skc,
599                                                    0x10,
600                                                    DIGEST_ALGO_RMD160 );
601                     if( rc ) {
602                         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc));
603                         goto leave;
604                     }
605
606                     pkt = m_alloc_clear( sizeof *pkt );
607                     pkt->pkttype = PKT_SIGNATURE;
608                     pkt->pkt.signature = sig;
609                     add_kbnode_as_child( node, new_kbnode( pkt ) );
610                 }
611             }
612         }
613     }
614
615     rc = update_keyblock( &kbpos, keyblock );
616     if( rc ) {
617         log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
618         goto leave;
619     }
620
621   leave:
622     release_kbnode( keyblock );
623     release_skc_list( skc_list );
624     rmd160_close( mfx.rmd160 );
625     return rc;
626 }
627
628
629
630 int
631 edit_keysigs( const char *username )
632 {
633     int rc = 0;
634     KBNODE keyblock = NULL;
635     KBNODE kbctx, node;
636     KBPOS kbpos;
637     PKT_public_cert *pkc;
638     int any;
639     u32 pkc_keyid[2];
640     char *answer;
641
642     /* search the userid */
643     rc = search_keyblock_byname( &kbpos, username );
644     if( rc ) {
645         log_error("user '%s' not found\n", username );
646         goto leave;
647     }
648
649     /* read the keyblock */
650     rc = read_keyblock( &kbpos, &keyblock );
651     if( rc ) {
652         log_error("error reading the certificate: %s\n", g10_errstr(rc) );
653         goto leave;
654     }
655
656     /* get the keyid from the keyblock */
657     for( kbctx=NULL; (node=walk_kbtree( keyblock, &kbctx)) ; ) {
658         if( node->pkt->pkttype == PKT_PUBLIC_CERT )
659             break;
660     }
661     if( !node ) {
662         log_error("Oops; public key not found anymore!\n");
663         rc = G10ERR_GENERAL;
664         goto leave;
665     }
666
667     pkc = node->pkt->pkt.public_cert;
668     keyid_from_pkc( pkc, pkc_keyid );
669     log_info("Checking signatures of this public key certificate:\n");
670     tty_printf("pub  %4u%c/%08lX %s   ",
671               nbits_from_pkc( pkc ),
672               pubkey_letter( pkc->pubkey_algo ),
673               pkc_keyid[1], datestr_from_pkc(pkc) );
674     {
675         size_t n;
676         char *p = get_user_id( pkc_keyid, &n );
677         tty_print_string( p, n > 40? 40 : n );
678         m_free(p);
679         tty_printf("\n");
680     }
681
682     clear_kbnode_flags( keyblock );
683     check_all_keysigs( keyblock );
684     if( remove_keysigs( keyblock, 1 ) ) {
685         rc = update_keyblock( &kbpos, keyblock );
686         if( rc ) {
687             log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
688             goto leave;
689         }
690     }
691
692   leave:
693     release_kbnode( keyblock );
694     return rc;
695 }
696
697
698
699 /****************
700  * Create a signature packet for the given public key certificate
701  * and the user id and return it in ret_sig. User signature class SIGCLASS
702  */
703 int
704 make_keysig_packet( PKT_signature **ret_sig, PKT_public_cert *pkc,
705                     PKT_user_id *uid, PKT_secret_cert *skc,
706                     int sigclass, int digest_algo )
707 {
708     PKT_signature *sig;
709     int rc=0;
710     MD_HANDLE *md;
711
712     assert( sigclass >= 0x10 && sigclass <= 0x13 );
713     md = md_open( digest_algo, 0 );
714     /* hash the public key certificate */
715     hash_public_cert( md, pkc );
716     md_write( md, uid->name, uid->len );
717     /* and make the signature packet */
718     sig = m_alloc_clear( sizeof *sig );
719     sig->pubkey_algo = skc->pubkey_algo;
720     sig->timestamp = make_timestamp();
721     sig->sig_class = sigclass;
722
723     md_putchar( md, sig->sig_class );
724     {   u32 a = sig->timestamp;
725         md_putchar( md, (a >> 24) & 0xff );
726         md_putchar( md, (a >> 16) & 0xff );
727         md_putchar( md, (a >>  8) & 0xff );
728         md_putchar( md,  a        & 0xff );
729     }
730
731     rc = complete_sig( sig, skc, md );
732
733     md_close( md );
734     if( rc )
735         free_seckey_enc( sig );
736     else
737         *ret_sig = sig;
738     return rc;
739 }
740