090c12b7a657f42b463c7b4ce7b2818f20e4ed1a
[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 "trustdb.h"
39 #include "i18n.h"
40
41
42
43 /****************
44  * Create a notation.  It is assumed that the stings in STRLIST
45  * are already checked to contain only printable data and have a valid
46  * NAME=VALUE format.
47  */
48 static void
49 mk_notation_and_policy( PKT_signature *sig )
50 {
51     const char *string, *s;
52     byte *buf;
53     unsigned n1, n2;
54
55     /* notation data */
56     if( opt.notation_data && sig->version < 4 )
57         log_info("can't put notation data into v3 signatures\n");
58     else if( opt.notation_data ) {
59         STRLIST nd = opt.notation_data;
60
61         for( ; nd; nd = nd->next )  {
62             string = nd->d;
63             s = strchr( string, '=' );
64             if( !s )
65                 BUG(); /* we have already parsed this */
66             n1 = s - string;
67             s++;
68             n2 = strlen(s);
69             buf = m_alloc( 8 + n1 + n2 );
70             buf[0] = 0x80; /* human readable */
71             buf[1] = buf[2] = buf[3] = 0;
72             buf[4] = n1 >> 8;
73             buf[5] = n1;
74             buf[6] = n2 >> 8;
75             buf[7] = n2;
76             memcpy(buf+8, string, n1 );
77             memcpy(buf+8+n1, s, n2 );
78             build_sig_subpkt( sig, SIGSUBPKT_NOTATION
79                               | ((nd->flags & 1)? SIGSUBPKT_FLAG_CRITICAL:0),
80                               buf, 8+n1+n2 );
81         }
82     }
83
84     /* set policy URL */
85     if( (s=opt.set_policy_url) ) {
86         if( *s == '!' )
87             build_sig_subpkt( sig, SIGSUBPKT_POLICY | SIGSUBPKT_FLAG_CRITICAL,
88                               s+1, strlen(s+1) );
89         else
90             build_sig_subpkt( sig, SIGSUBPKT_POLICY, s, strlen(s) );
91     }
92 }
93
94
95 static int
96 do_sign( PKT_secret_key *sk, PKT_signature *sig,
97          MD_HANDLE md, int digest_algo )
98 {
99     MPI frame;
100     byte *dp;
101     int rc;
102
103     if( sk->timestamp > sig->timestamp ) {
104         ulong d = sk->timestamp - sig->timestamp;
105         log_info( d==1 ? _("key has been created %lu second "
106                            "in future (time warp or clock problem)\n")
107                        : _("key has been created %lu seconds "
108                            "in future (time warp or clock problem)\n"), d );
109         return G10ERR_TIME_CONFLICT;
110     }
111
112
113     print_pubkey_algo_note(sk->pubkey_algo);
114
115     if( !digest_algo )
116         digest_algo = md_get_algo(md);
117
118     print_digest_algo_note( digest_algo );
119     dp = md_read( md, digest_algo );
120     sig->digest_algo = digest_algo;
121     sig->digest_start[0] = dp[0];
122     sig->digest_start[1] = dp[1];
123     frame = encode_md_value( sk->pubkey_algo, md,
124                              digest_algo, mpi_get_nbits(sk->skey[0]));
125     rc = pubkey_sign( sk->pubkey_algo, sig->data, frame, sk->skey );
126     mpi_free(frame);
127     if( rc )
128         log_error(_("signing failed: %s\n"), g10_errstr(rc) );
129     else {
130         if( opt.verbose ) {
131             char *ustr = get_user_id_string( sig->keyid );
132             log_info(_("%s signature from: %s\n"),
133                       pubkey_algo_to_string(sk->pubkey_algo), ustr );
134             m_free(ustr);
135         }
136     }
137     return rc;
138 }
139
140
141
142 int
143 complete_sig( PKT_signature *sig, PKT_secret_key *sk, MD_HANDLE md )
144 {
145     int rc=0;
146
147     if( !(rc=check_secret_key( sk, 0 )) )
148         rc = do_sign( sk, sig, md, 0 );
149
150     /* fixme: should we check whether the signature is okay?
151      * maybe by using an option */
152
153     return rc;
154 }
155
156 static int
157 hash_for(int pubkey_algo )
158 {
159     if( opt.def_digest_algo )
160         return opt.def_digest_algo;
161     if( pubkey_algo == PUBKEY_ALGO_DSA )
162         return DIGEST_ALGO_SHA1;
163     if( pubkey_algo == PUBKEY_ALGO_RSA )
164         return DIGEST_ALGO_MD5;
165     return DEFAULT_DIGEST_ALGO;
166 }
167
168 static int
169 only_old_style( SK_LIST sk_list )
170 {
171     SK_LIST sk_rover = NULL;
172     int old_style = 0;
173
174     /* if there are only old style capable key we use the old sytle */
175     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
176         PKT_secret_key *sk = sk_rover->sk;
177         if( sk->pubkey_algo == PUBKEY_ALGO_RSA && sk->version < 4 )
178             old_style = 1;
179         else
180             return 0;
181     }
182     return old_style;
183 }
184
185
186
187 /****************
188  * Sign the files whose names are in FILENAME.
189  * If DETACHED has the value true,
190  * make a detached signature.  If FILENAMES->d is NULL read from stdin
191  * and ignore the detached mode.  Sign the file with all secret keys
192  * which can be taken from LOCUSR, if this is NULL, use the default one
193  * If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
194  * signed data for these users.
195  * If OUTFILE is not NULL; this file is used for output and the function
196  * does not ask for overwrite permission; output is then always
197  * uncompressed, non-armored and in binary mode.
198  */
199 int
200 sign_file( STRLIST filenames, int detached, STRLIST locusr,
201            int encrypt, STRLIST remusr, const char *outfile )
202 {
203     const char *fname;
204     armor_filter_context_t afx;
205     compress_filter_context_t zfx;
206     md_filter_context_t mfx;
207     text_filter_context_t tfx;
208     encrypt_filter_context_t efx;
209     IOBUF inp = NULL, out = NULL;
210     PACKET pkt;
211     PKT_plaintext *pt = NULL;
212     u32 filesize;
213     int rc = 0;
214     PK_LIST pk_list = NULL;
215     SK_LIST sk_list = NULL;
216     SK_LIST sk_rover = NULL;
217     int multifile = 0;
218     int old_style = opt.rfc1991;
219     int compr_algo = -1; /* unknown */
220
221
222     memset( &afx, 0, sizeof afx);
223     memset( &zfx, 0, sizeof zfx);
224     memset( &mfx, 0, sizeof mfx);
225     memset( &tfx, 0, sizeof tfx);
226     memset( &efx, 0, sizeof efx);
227     init_packet( &pkt );
228
229     if( filenames ) {
230         fname = filenames->d;
231         multifile = !!filenames->next;
232     }
233     else
234         fname = NULL;
235
236     if( fname && filenames->next && (!detached || encrypt) )
237         log_bug("multiple files can only be detached signed");
238
239     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
240         goto leave;
241     if( !old_style )
242         old_style = only_old_style( sk_list );
243
244     if( encrypt ) {
245         if( (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )) )
246             goto leave;
247         if( !old_style )
248             compr_algo = select_algo_from_prefs( pk_list, PREFTYPE_COMPR );
249     }
250
251     /* prepare iobufs */
252     if( multifile )  /* have list of filenames */
253         inp = NULL; /* we do it later */
254     else if( !(inp = iobuf_open(fname)) ) {
255         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
256                                         strerror(errno) );
257         rc = G10ERR_OPEN_FILE;
258         goto leave;
259     }
260
261     if( outfile ) {
262         if( !(out = iobuf_create( outfile )) ) {
263             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
264             rc = G10ERR_CREATE_FILE;
265             goto leave;
266         }
267         else if( opt.verbose )
268             log_info(_("writing to `%s'\n"), outfile );
269     }
270     else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
271         goto leave;
272
273     /* prepare to calculate the MD over the input */
274     if( opt.textmode && !outfile )
275         iobuf_push_filter( inp, text_filter, &tfx );
276     mfx.md = md_open(0, 0);
277
278     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
279         PKT_secret_key *sk = sk_rover->sk;
280         md_enable(mfx.md, hash_for(sk->pubkey_algo));
281     }
282
283     if( !multifile )
284         iobuf_push_filter( inp, md_filter, &mfx );
285
286     if( detached && !encrypt && !opt.rfc1991 )
287         afx.what = 2;
288
289     if( opt.armor && !outfile  )
290         iobuf_push_filter( out, armor_filter, &afx );
291   #ifdef ENABLE_COMMENT_PACKETS
292     else {
293         write_comment( out, "#created by GNUPG v" VERSION " ("
294                                             PRINTABLE_OS_NAME ")");
295         if( opt.comment_string )
296             write_comment( out, opt.comment_string );
297     }
298   #endif
299     if( encrypt ) {
300         efx.pk_list = pk_list;
301         /* fixme: set efx.cfx.datalen if known */
302         iobuf_push_filter( out, encrypt_filter, &efx );
303     }
304
305     if( opt.compress && !outfile && ( !detached || opt.compress_sigs) ) {
306         if( !compr_algo )
307             ; /* don't use compression */
308         else {
309             if( old_style
310                 || compr_algo == 1
311                 || (compr_algo == -1 && !encrypt) )
312                 zfx.algo = 1; /* use the non optional algorithm */
313             iobuf_push_filter( out, compress_filter, &zfx );
314         }
315     }
316
317     if( !detached && !old_style ) {
318         int skcount=0;
319         /* loop over the secret certificates and build headers
320          * The specs now say that the data should be bracket by
321          * the onepass-sig and signature-packet; so we must build it
322          * here in reverse order */
323         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
324             skcount++;
325         for( ; skcount; skcount-- ) {
326             PKT_secret_key *sk;
327             PKT_onepass_sig *ops;
328             int i = 0;
329
330             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
331                 if( ++i == skcount )
332                     break;
333
334             sk = sk_rover->sk;
335             ops = m_alloc_clear( sizeof *ops );
336             ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
337             ops->digest_algo = hash_for(sk->pubkey_algo);
338             ops->pubkey_algo = sk->pubkey_algo;
339             keyid_from_sk( sk, ops->keyid );
340             ops->last = skcount == 1;
341
342             init_packet(&pkt);
343             pkt.pkttype = PKT_ONEPASS_SIG;
344             pkt.pkt.onepass_sig = ops;
345             rc = build_packet( out, &pkt );
346             free_packet( &pkt );
347             if( rc ) {
348                 log_error("build onepass_sig packet failed: %s\n",
349                                                         g10_errstr(rc));
350                 goto leave;
351             }
352         }
353     }
354
355     /* setup the inner packet */
356     if( detached ) {
357         if( multifile ) {
358             STRLIST sl;
359
360             if( opt.verbose )
361                 log_info(_("signing:") );
362             /* must walk reverse trough this list */
363             for( sl = strlist_last(filenames); sl;
364                         sl = strlist_prev( filenames, sl ) ) {
365                 if( !(inp = iobuf_open(sl->d)) ) {
366                     log_error(_("can't open %s: %s\n"),
367                                             sl->d, strerror(errno) );
368                     rc = G10ERR_OPEN_FILE;
369                     goto leave;
370                 }
371                 if( opt.verbose )
372                     fprintf(stderr, " `%s'", sl->d );
373                 iobuf_push_filter( inp, md_filter, &mfx );
374                 while( iobuf_get(inp) != -1 )
375                     ;
376                 iobuf_close(inp); inp = NULL;
377             }
378             if( opt.verbose )
379                 putc( '\n', stderr );
380         }
381         else {
382             /* read, so that the filter can calculate the digest */
383             while( iobuf_get(inp) != -1 )
384                 ;
385         }
386     }
387     else {
388         if (!opt.no_literal)
389             if( fname || opt.set_filename ) {
390                 char *s = make_basename( opt.set_filename ? opt.set_filename : fname );
391                 pt = m_alloc( sizeof *pt + strlen(s) - 1 );
392                 pt->namelen = strlen(s);
393                 memcpy(pt->name, s, pt->namelen );
394                 m_free(s);
395             }
396             else { /* no filename */
397                 pt = m_alloc( sizeof *pt - 1 );
398                 pt->namelen = 0;
399             }
400
401         if( fname ) {
402             if( !(filesize = iobuf_get_filelength(inp)) )
403                 log_info(_("WARNING: `%s' is an empty file\n"), fname );
404
405             /* because the text_filter modifies the length of the
406              * data, it is not possible to know the used length
407              * without a double read of the file - to avoid that
408              * we simple use partial length packets.
409              */
410             if( opt.textmode && !outfile )
411                 filesize = 0;
412         }
413         else
414             filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
415         
416         if (!opt.no_literal) {
417             pt->timestamp = make_timestamp();
418             pt->mode = opt.textmode && !outfile ? 't':'b';
419             pt->len = filesize;
420             pt->new_ctb = !pt->len && !opt.rfc1991;
421             pt->buf = inp;
422             pkt.pkttype = PKT_PLAINTEXT;
423             pkt.pkt.plaintext = pt;
424             /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
425             if( (rc = build_packet( out, &pkt )) )
426                 log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
427             pt->buf = NULL;
428         }
429         else {
430             byte copy_buffer[4096];
431             int  bytes_copied;
432             while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
433                 if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
434                     rc = G10ERR_WRITE_FILE;
435                     log_error("copying input to output failed: %s\n", g10_errstr(rc));
436                     break;
437                 }
438             memset(copy_buffer, 0, 4096); /* burn buffer */
439         }
440     }
441
442     /* catch errors from above blocks */
443     if (rc)
444         goto leave;
445
446     /* loop over the secret certificates */
447     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
448         PKT_secret_key *sk;
449         PKT_signature *sig;
450         MD_HANDLE md;
451
452         sk = sk_rover->sk;
453
454         /* build the signature packet */
455         /* fixme: this code is partly duplicated in make_keysig_packet */
456         sig = m_alloc_clear( sizeof *sig );
457         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
458         keyid_from_sk( sk, sig->keyid );
459         sig->digest_algo = hash_for(sk->pubkey_algo);
460         sig->pubkey_algo = sk->pubkey_algo;
461         sig->timestamp = make_timestamp();
462         sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
463
464         md = md_copy( mfx.md );
465
466         if( sig->version >= 4 ) {
467             build_sig_subpkt_from_sig( sig );
468             md_putc( md, sig->version );
469         }
470
471         mk_notation_and_policy( sig );
472
473         md_putc( md, sig->sig_class );
474         if( sig->version < 4 ) {
475             u32 a = sig->timestamp;
476             md_putc( md, (a >> 24) & 0xff );
477             md_putc( md, (a >> 16) & 0xff );
478             md_putc( md, (a >>  8) & 0xff );
479             md_putc( md,  a        & 0xff );
480         }
481         else {
482             byte buf[6];
483             size_t n;
484
485             md_putc( md, sig->pubkey_algo );
486             md_putc( md, sig->digest_algo );
487             if( sig->hashed_data ) {
488                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
489                 md_write( md, sig->hashed_data, n+2 );
490                 n += 6;
491             }
492             else {
493                 md_putc( md, 0 );  /* always hash the length of the subpacket*/
494                 md_putc( md, 0 );
495                 n = 6;
496             }
497             /* add some magic */
498             buf[0] = sig->version;
499             buf[1] = 0xff;
500             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
501             buf[3] = n >> 16;
502             buf[4] = n >>  8;
503             buf[5] = n;
504             md_write( md, buf, 6 );
505
506         }
507         md_final( md );
508
509         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
510         md_close( md );
511
512         if( !rc ) { /* and write it */
513             init_packet(&pkt);
514             pkt.pkttype = PKT_SIGNATURE;
515             pkt.pkt.signature = sig;
516             rc = build_packet( out, &pkt );
517             free_packet( &pkt );
518             if( rc )
519                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
520         }
521         if( rc )
522             goto leave;
523     }
524
525
526   leave:
527     if( rc )
528         iobuf_cancel(out);
529     else
530         iobuf_close(out);
531     iobuf_close(inp);
532     md_close( mfx.md );
533     release_sk_list( sk_list );
534     release_pk_list( pk_list );
535     return rc;
536 }
537
538
539
540 /****************
541  * make a clear signature. note that opt.armor is not needed
542  */
543 int
544 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
545 {
546     armor_filter_context_t afx;
547     MD_HANDLE textmd = NULL;
548     IOBUF inp = NULL, out = NULL;
549     PACKET pkt;
550     int rc = 0;
551     SK_LIST sk_list = NULL;
552     SK_LIST sk_rover = NULL;
553     int old_style = opt.rfc1991;
554     int only_md5 = 0;
555
556     memset( &afx, 0, sizeof afx);
557     init_packet( &pkt );
558
559     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
560         goto leave;
561     if( !old_style )
562         old_style = only_old_style( sk_list );
563
564     /* prepare iobufs */
565     if( !(inp = iobuf_open(fname)) ) {
566         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
567                                         strerror(errno) );
568         rc = G10ERR_OPEN_FILE;
569         goto leave;
570     }
571
572     if( outfile ) {
573         if( !(out = iobuf_create( outfile )) ) {
574             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
575             rc = G10ERR_CREATE_FILE;
576             goto leave;
577         }
578         else if( opt.verbose )
579             log_info(_("writing to `%s'\n"), outfile );
580     }
581     else if( (rc = open_outfile( fname, 1, &out )) )
582         goto leave;
583
584     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n" );
585
586     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
587         PKT_secret_key *sk = sk_rover->sk;
588         if( hash_for(sk->pubkey_algo) == DIGEST_ALGO_MD5 )
589             only_md5 = 1;
590         else {
591             only_md5 = 0;
592             break;
593         }
594     }
595
596     if( old_style || only_md5 )
597         iobuf_writestr(out, "\n" );
598     else {
599         const char *s;
600         int any = 0;
601
602         iobuf_writestr(out, "Hash: " );
603         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
604             PKT_secret_key *sk = sk_rover->sk;
605             s = digest_algo_to_string( hash_for(sk->pubkey_algo) );
606             if( s ) {
607                 if( any )
608                     iobuf_put(out, ',' );
609                 iobuf_writestr(out, s );
610                 any = 1;
611             }
612         }
613         assert(any);
614         iobuf_writestr(out, "\n" );
615         if( opt.not_dash_escaped )
616             iobuf_writestr( out,
617                 "NotDashEscaped: You need GnuPG to verify this message\n" );
618         iobuf_writestr(out, "\n" );
619     }
620
621
622     textmd = md_open(0, 0);
623     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
624         PKT_secret_key *sk = sk_rover->sk;
625         md_enable(textmd, hash_for(sk->pubkey_algo));
626     }
627     /*md_start_debug( textmd, "sign" );*/
628     copy_clearsig_text( out, inp, textmd,
629                         !opt.not_dash_escaped, opt.escape_from, old_style );
630     /* fixme: check for read errors */
631
632     /* now write the armor */
633     afx.what = 2;
634     iobuf_push_filter( out, armor_filter, &afx );
635
636     /* loop over the secret certificates */
637     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
638         PKT_secret_key *sk;
639         PKT_signature *sig;
640         MD_HANDLE md;
641
642         sk = sk_rover->sk;
643
644         /* build the signature packet */
645         /* fixme: this code is duplicated above */
646         sig = m_alloc_clear( sizeof *sig );
647         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
648         keyid_from_sk( sk, sig->keyid );
649         sig->digest_algo = hash_for(sk->pubkey_algo);
650         sig->pubkey_algo = sk->pubkey_algo;
651         sig->timestamp = make_timestamp();
652         sig->sig_class = 0x01;
653
654         md = md_copy( textmd );
655         if( sig->version >= 4 ) {
656             build_sig_subpkt_from_sig( sig );
657             md_putc( md, sig->version );
658         }
659
660         mk_notation_and_policy( sig );
661
662         md_putc( md, sig->sig_class );
663         if( sig->version < 4 ) {
664             u32 a = sig->timestamp;
665             md_putc( md, (a >> 24) & 0xff );
666             md_putc( md, (a >> 16) & 0xff );
667             md_putc( md, (a >>  8) & 0xff );
668             md_putc( md,  a        & 0xff );
669         }
670         else {
671             byte buf[6];
672             size_t n;
673
674             md_putc( md, sig->pubkey_algo );
675             md_putc( md, sig->digest_algo );
676             if( sig->hashed_data ) {
677                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
678                 md_write( md, sig->hashed_data, n+2 );
679                 n += 6;
680             }
681             else {
682                 md_putc( md, 0 );  /* always hash the length of the subpacket*/
683                 md_putc( md, 0 );
684                 n = 6;
685             }
686             /* add some magic */
687             buf[0] = sig->version;
688             buf[1] = 0xff;
689             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
690             buf[3] = n >> 16;
691             buf[4] = n >>  8;
692             buf[5] = n;
693             md_write( md, buf, 6 );
694
695         }
696         md_final( md );
697
698         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
699         md_close( md );
700
701         if( !rc ) { /* and write it */
702             init_packet(&pkt);
703             pkt.pkttype = PKT_SIGNATURE;
704             pkt.pkt.signature = sig;
705             rc = build_packet( out, &pkt );
706             free_packet( &pkt );
707             if( rc )
708                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
709         }
710         if( rc )
711             goto leave;
712     }
713
714
715   leave:
716     if( rc )
717         iobuf_cancel(out);
718     else
719         iobuf_close(out);
720     iobuf_close(inp);
721     md_close( textmd );
722     release_sk_list( sk_list );
723     return rc;
724 }
725
726
727 /****************
728  * Create a signature packet for the given public key certificate
729  * and the user id and return it in ret_sig. User signature class SIGCLASS
730  * user-id is not used (and may be NULL if sigclass is 0x20)
731  * If digest_algo is 0 the function selects an appropriate one.
732  */
733 int
734 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
735                     PKT_user_id *uid, PKT_public_key *subpk,
736                     PKT_secret_key *sk,
737                     int sigclass, int digest_algo,
738                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
739                    )
740 {
741     PKT_signature *sig;
742     int rc=0;
743     MD_HANDLE md;
744
745     assert( (sigclass >= 0x10 && sigclass <= 0x13)
746             || sigclass == 0x20 || sigclass == 0x18
747             || sigclass == 0x30 || sigclass == 0x28 );
748     if( !digest_algo ) {
749         switch( sk->pubkey_algo ) {
750           case PUBKEY_ALGO_DSA: digest_algo = DIGEST_ALGO_SHA1; break;
751           case PUBKEY_ALGO_RSA_S:
752           case PUBKEY_ALGO_RSA: digest_algo = DIGEST_ALGO_MD5; break;
753           default:              digest_algo = DIGEST_ALGO_RMD160; break;
754         }
755     }
756     md = md_open( digest_algo, 0 );
757
758     /* hash the public key certificate and the user id */
759     hash_public_key( md, pk );
760     if( sigclass == 0x18 || sigclass == 0x28 ) { /* subkey binding/revocation*/
761         hash_public_key( md, subpk );
762     }
763     else if( sigclass != 0x20 ) {
764         if( sk->version >=4 ) {
765             byte buf[5];
766             buf[0] = 0xb4;            /* indicates a userid packet */
767             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
768             buf[2] = uid->len >> 16;
769             buf[3] = uid->len >>  8;
770             buf[4] = uid->len;
771             md_write( md, buf, 5 );
772         }
773         md_write( md, uid->name, uid->len );
774     }
775     /* and make the signature packet */
776     sig = m_alloc_clear( sizeof *sig );
777     sig->version = sk->version;
778     keyid_from_sk( sk, sig->keyid );
779     sig->pubkey_algo = sk->pubkey_algo;
780     sig->digest_algo = digest_algo;
781     sig->timestamp = make_timestamp();
782     sig->sig_class = sigclass;
783     if( sig->version >= 4 )
784         build_sig_subpkt_from_sig( sig );
785
786     if( sig->version >= 4 && mksubpkt )
787         rc = (*mksubpkt)( sig, opaque );
788
789     if( !rc ) {
790         mk_notation_and_policy( sig );
791         if( sig->version >= 4 )
792             md_putc( md, sig->version );
793         md_putc( md, sig->sig_class );
794         if( sig->version < 4 ) {
795             u32 a = sig->timestamp;
796             md_putc( md, (a >> 24) & 0xff );
797             md_putc( md, (a >> 16) & 0xff );
798             md_putc( md, (a >>  8) & 0xff );
799             md_putc( md,  a        & 0xff );
800         }
801         else {
802             byte buf[6];
803             size_t n;
804
805             md_putc( md, sig->pubkey_algo );
806             md_putc( md, sig->digest_algo );
807             if( sig->hashed_data ) {
808                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
809                 md_write( md, sig->hashed_data, n+2 );
810                 n += 6;
811             }
812             else {
813                 md_putc( md, 0 );  /* always hash the length of the subpacket*/
814                 md_putc( md, 0 );
815                 n = 6;
816             }
817             /* add some magic */
818             buf[0] = sig->version;
819             buf[1] = 0xff;
820             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
821             buf[3] = n >> 16;
822             buf[4] = n >>  8;
823             buf[5] = n;
824             md_write( md, buf, 6 );
825
826         }
827         md_final(md);
828
829         rc = complete_sig( sig, sk, md );
830     }
831
832     md_close( md );
833     if( rc )
834         free_seckey_enc( sig );
835     else
836         *ret_sig = sig;
837     return rc;
838 }
839
840