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