See ChangeLog: Wed Jan 20 18:59:49 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              */
353             if( opt.textmode && !outfile )
354                 filesize = 0;
355         }
356         else
357             filesize = 0; /* stdin */
358         pt->timestamp = make_timestamp();
359         pt->mode = opt.textmode && !outfile ? 't':'b';
360         pt->len = filesize;
361         pt->new_ctb = !pt->len && !opt.rfc1991;
362         pt->buf = inp;
363         pkt.pkttype = PKT_PLAINTEXT;
364         pkt.pkt.plaintext = pt;
365         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
366         if( (rc = build_packet( out, &pkt )) )
367             log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
368         pt->buf = NULL;
369     }
370
371     /* loop over the secret certificates */
372     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
373         PKT_secret_key *sk;
374         PKT_signature *sig;
375         MD_HANDLE md;
376
377         sk = sk_rover->sk;
378
379         /* build the signature packet */
380         /* fixme: this code is partly duplicated in make_keysig_packet */
381         sig = m_alloc_clear( sizeof *sig );
382         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
383         keyid_from_sk( sk, sig->keyid );
384         sig->digest_algo = hash_for(sk->pubkey_algo);
385         sig->pubkey_algo = sk->pubkey_algo;
386         sig->timestamp = make_timestamp();
387         sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
388
389         md = md_copy( mfx.md );
390
391         if( sig->version >= 4 ) {
392             build_sig_subpkt_from_sig( sig );
393             md_putc( md, sig->version );
394         }
395         md_putc( md, sig->sig_class );
396         if( sig->version < 4 ) {
397             u32 a = sig->timestamp;
398             md_putc( md, (a >> 24) & 0xff );
399             md_putc( md, (a >> 16) & 0xff );
400             md_putc( md, (a >>  8) & 0xff );
401             md_putc( md,  a        & 0xff );
402         }
403         else {
404             byte buf[6];
405             size_t n;
406
407             md_putc( md, sig->pubkey_algo );
408             md_putc( md, sig->digest_algo );
409             if( sig->hashed_data ) {
410                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
411                 md_write( md, sig->hashed_data, n+2 );
412                 n += 6;
413             }
414             else
415                 n = 6;
416             /* add some magic */
417             buf[0] = sig->version;
418             buf[1] = 0xff;
419             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
420             buf[3] = n >> 16;
421             buf[4] = n >>  8;
422             buf[5] = n;
423             md_write( md, buf, 6 );
424
425         }
426         md_final( md );
427
428         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
429         md_close( md );
430
431         if( !rc ) { /* and write it */
432             init_packet(&pkt);
433             pkt.pkttype = PKT_SIGNATURE;
434             pkt.pkt.signature = sig;
435             rc = build_packet( out, &pkt );
436             free_packet( &pkt );
437             if( rc )
438                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
439         }
440         if( rc )
441             goto leave;
442     }
443
444
445   leave:
446     if( rc )
447         iobuf_cancel(out);
448     else
449         iobuf_close(out);
450     iobuf_close(inp);
451     md_close( mfx.md );
452     release_sk_list( sk_list );
453     release_pk_list( pk_list );
454     return rc;
455 }
456
457
458 #if 0
459 /****************
460  * Note: We do not calculate the hash over the last CR,LF
461  */
462 static int
463 write_dash_escaped( IOBUF inp, IOBUF out, MD_HANDLE md )
464 {
465     int c;
466     int lastlf = 1;
467     int state = 0;
468
469     if( opt.not_dash_escaped ) {
470         lastlf = 0;
471         while( (c = iobuf_get(inp)) != -1 ) {
472             md_putc(md, c );
473             iobuf_put( out, c );
474             lastlf = c;
475         }
476         if( lastlf != '\n' ) {
477             /* add a missing trailing LF */
478             md_putc(md, '\n' );
479             iobuf_put( out, '\n' );
480         }
481
482         return 0;
483     }
484
485     while( (c = iobuf_get(inp)) != -1 ) {
486         if( lastlf ) {
487             if( c == '-' ) {
488                 iobuf_put( out, c );
489                 iobuf_put( out, ' ' );
490             }
491             else if( c == 'F' && opt.escape_from ) {
492                 int i;
493
494                 if( state >= 1 )
495                     md_putc(md, '\r');
496                 if( state >= 2 )
497                     md_putc(md, '\n');
498                 state = 0;
499
500                 for( i=1; i < 5 && (c = iobuf_get(inp)) != -1; i++ ) {
501                     if( "From "[i] != c )
502                         break;
503                 }
504                 if( i < 5 ) {
505                     iobuf_write( out, "From", i );
506                     md_write( md, "From", i );
507                     if( c == -1 )
508                         break;
509                 }
510                 else {
511                     iobuf_writestr( out, "- From" );
512                     md_write( md, "From", 4 );
513                 }
514             }
515         }
516
517       again:
518         switch( state ) {
519           case 0:
520             if( c == '\r' )
521                 state = 1;
522             else
523                 md_putc(md, c );
524             break;
525           case 1:
526             if( c == '\n' )
527                 state = 2;
528             else {
529                 md_putc(md, '\r');
530                 state = 0;
531                 goto again;
532             }
533             break;
534           case 2:
535             md_putc(md, '\r');
536             md_putc(md, '\n');
537             state = 0;
538             goto again;
539           default: BUG();
540         }
541         iobuf_put( out, c );
542         lastlf = c == '\n';
543     }
544     if( state == 1 )
545         md_putc(md, '\r');
546     else if( state == 2 ) {  /* file ended with a new line */
547         md_putc(md, '\r');
548         md_putc(md, '\n');
549         iobuf_put( out, '\n');
550     }
551
552     if( !lastlf )
553         iobuf_put( out, '\n' );
554
555     return 0; /* fixme: add error handling */
556 }
557 #endif
558
559 /****************
560  * make a clear signature. note that opt.armor is not needed
561  */
562 int
563 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
564 {
565     armor_filter_context_t afx;
566     text_filter_context_t tfx;
567     MD_HANDLE textmd = NULL;
568     IOBUF inp = NULL, out = NULL;
569     PACKET pkt;
570     int rc = 0;
571     SK_LIST sk_list = NULL;
572     SK_LIST sk_rover = NULL;
573     int old_style = opt.rfc1991;
574     int only_md5 = 0;
575     int c;
576
577     memset( &afx, 0, sizeof afx);
578     memset( &tfx, 0, sizeof tfx);
579     init_packet( &pkt );
580
581     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
582         goto leave;
583     if( !old_style )
584         old_style = only_old_style( sk_list );
585
586     /* prepare iobufs */
587     if( !(inp = iobuf_open(fname)) ) {
588         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
589                                         strerror(errno) );
590         rc = G10ERR_OPEN_FILE;
591         goto leave;
592     }
593
594     if( outfile ) {
595         if( !(out = iobuf_create( outfile )) ) {
596             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
597             rc = G10ERR_CREATE_FILE;
598             goto leave;
599         }
600         else if( opt.verbose )
601             log_info(_("writing to `%s'\n"), outfile );
602     }
603     else if( (rc = open_outfile( fname, 1, &out )) )
604         goto leave;
605
606     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n" );
607
608     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
609         PKT_secret_key *sk = sk_rover->sk;
610         if( hash_for(sk->pubkey_algo) == DIGEST_ALGO_MD5 )
611             only_md5 = 1;
612         else {
613             only_md5 = 0;
614             break;
615         }
616     }
617
618     if( old_style || only_md5 )
619         iobuf_writestr(out, "\n" );
620     else {
621         const char *s;
622         int any = 0;
623
624         iobuf_writestr(out, "Hash: " );
625         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
626             PKT_secret_key *sk = sk_rover->sk;
627             s = digest_algo_to_string( hash_for(sk->pubkey_algo) );
628             if( s ) {
629                 if( any )
630                     iobuf_put(out, ',' );
631                 iobuf_writestr(out, s );
632                 any = 1;
633             }
634         }
635         assert(any);
636         iobuf_writestr(out, "\n" );
637         if( opt.not_dash_escaped )
638             iobuf_writestr( out,
639                 "NotDashEscaped: You need GnuPG to verify this message\n" );
640         iobuf_writestr(out, "\n" );
641     }
642
643
644     textmd = md_open(0, 0);
645     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
646         PKT_secret_key *sk = sk_rover->sk;
647         md_enable(textmd, hash_for(sk->pubkey_algo));
648     }
649     md_start_debug( textmd, "sign" );
650     tfx.clearsign = 1;
651     tfx.not_dash_escaped = opt.not_dash_escaped;
652     tfx.escape_from = opt.escape_from;
653     tfx.md = textmd;
654     iobuf_push_filter( inp, text_filter, &tfx );
655     /* read input and write it to the output.  The textfilter handles
656      * the calculation of the hash and the dash escaping */
657     while( (c=iobuf_get(inp)) != -1 )  {
658         if( iobuf_put(out, c) == -1 ) {
659             rc = G10ERR_WRITE_FILE;
660             goto leave;
661         }
662     }
663     /* fixme: check for read errors */
664
665     /* now write the armor */
666     afx.what = 2;
667     iobuf_push_filter( out, armor_filter, &afx );
668
669     /* loop over the secret certificates */
670     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
671         PKT_secret_key *sk;
672         PKT_signature *sig;
673         MD_HANDLE md;
674
675         sk = sk_rover->sk;
676
677         /* build the signature packet */
678         /* fixme: this code is duplicated above */
679         sig = m_alloc_clear( sizeof *sig );
680         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
681         keyid_from_sk( sk, sig->keyid );
682         sig->digest_algo = hash_for(sk->pubkey_algo);
683         sig->pubkey_algo = sk->pubkey_algo;
684         sig->timestamp = make_timestamp();
685         sig->sig_class = 0x01;
686
687         md = md_copy( textmd );
688         if( sig->version >= 4 ) {
689             build_sig_subpkt_from_sig( sig );
690             md_putc( md, sig->version );
691         }
692         md_putc( md, sig->sig_class );
693         if( sig->version < 4 ) {
694             u32 a = sig->timestamp;
695             md_putc( md, (a >> 24) & 0xff );
696             md_putc( md, (a >> 16) & 0xff );
697             md_putc( md, (a >>  8) & 0xff );
698             md_putc( md,  a        & 0xff );
699         }
700         else {
701             byte buf[6];
702             size_t n;
703
704             md_putc( md, sig->pubkey_algo );
705             md_putc( md, sig->digest_algo );
706             if( sig->hashed_data ) {
707                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
708                 md_write( md, sig->hashed_data, n+2 );
709                 n += 6;
710             }
711             else
712                 n = 6;
713             /* add some magic */
714             buf[0] = sig->version;
715             buf[1] = 0xff;
716             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
717             buf[3] = n >> 16;
718             buf[4] = n >>  8;
719             buf[5] = n;
720             md_write( md, buf, 6 );
721
722         }
723         md_final( md );
724
725         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
726         md_close( md );
727
728         if( !rc ) { /* and write it */
729             init_packet(&pkt);
730             pkt.pkttype = PKT_SIGNATURE;
731             pkt.pkt.signature = sig;
732             rc = build_packet( out, &pkt );
733             free_packet( &pkt );
734             if( rc )
735                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
736         }
737         if( rc )
738             goto leave;
739     }
740
741
742   leave:
743     if( rc )
744         iobuf_cancel(out);
745     else
746         iobuf_close(out);
747     iobuf_close(inp);
748     md_close( textmd );
749     release_sk_list( sk_list );
750     return rc;
751 }
752
753
754 /****************
755  * Create a signature packet for the given public key certificate
756  * and the user id and return it in ret_sig. User signature class SIGCLASS
757  * user-id is not used (and may be NULL if sigclass is 0x20)
758  * If digest_algo is 0 the function selects an appropriate one.
759  */
760 int
761 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
762                     PKT_user_id *uid, PKT_public_key *subpk,
763                     PKT_secret_key *sk,
764                     int sigclass, int digest_algo,
765                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
766                    )
767 {
768     PKT_signature *sig;
769     int rc=0;
770     MD_HANDLE md;
771
772     assert( (sigclass >= 0x10 && sigclass <= 0x13)
773             || sigclass == 0x20 || sigclass == 0x18 );
774     if( !digest_algo ) {
775         switch( sk->pubkey_algo ) {
776           case PUBKEY_ALGO_DSA: digest_algo = DIGEST_ALGO_SHA1; break;
777           case PUBKEY_ALGO_RSA_S:
778           case PUBKEY_ALGO_RSA: digest_algo = DIGEST_ALGO_MD5; break;
779           default:              digest_algo = DIGEST_ALGO_RMD160; break;
780         }
781     }
782     md = md_open( digest_algo, 0 );
783
784     /* hash the public key certificate and the user id */
785     hash_public_key( md, pk );
786     if( sigclass == 0x18 ) { /* subkey binding */
787         hash_public_key( md, subpk );
788     }
789     else if( sigclass != 0x20 ) {
790         if( sk->version >=4 ) {
791             byte buf[5];
792             buf[0] = 0xb4;            /* indicates a userid packet */
793             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
794             buf[2] = uid->len >> 16;
795             buf[3] = uid->len >>  8;
796             buf[4] = uid->len;
797             md_write( md, buf, 5 );
798         }
799         md_write( md, uid->name, uid->len );
800     }
801     /* and make the signature packet */
802     sig = m_alloc_clear( sizeof *sig );
803     sig->version = sk->version;
804     keyid_from_sk( sk, sig->keyid );
805     sig->pubkey_algo = sk->pubkey_algo;
806     sig->digest_algo = digest_algo;
807     sig->timestamp = make_timestamp();
808     sig->sig_class = sigclass;
809     if( sig->version >= 4 )
810         build_sig_subpkt_from_sig( sig );
811
812     if( sig->version >= 4 && mksubpkt )
813         rc = (*mksubpkt)( sig, opaque );
814
815     if( !rc ) {
816         if( sig->version >= 4 )
817             md_putc( md, sig->version );
818         md_putc( md, sig->sig_class );
819         if( sig->version < 4 ) {
820             u32 a = sig->timestamp;
821             md_putc( md, (a >> 24) & 0xff );
822             md_putc( md, (a >> 16) & 0xff );
823             md_putc( md, (a >>  8) & 0xff );
824             md_putc( md,  a        & 0xff );
825         }
826         else {
827             byte buf[6];
828             size_t n;
829
830             md_putc( md, sig->pubkey_algo );
831             md_putc( md, sig->digest_algo );
832             if( sig->hashed_data ) {
833                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
834                 md_write( md, sig->hashed_data, n+2 );
835                 n += 6;
836             }
837             else
838                 n = 6;
839             /* add some magic */
840             buf[0] = sig->version;
841             buf[1] = 0xff;
842             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
843             buf[3] = n >> 16;
844             buf[4] = n >>  8;
845             buf[5] = n;
846             md_write( md, buf, 6 );
847
848         }
849         md_final(md);
850
851         rc = complete_sig( sig, sk, md );
852     }
853
854     md_close( md );
855     if( rc )
856         free_seckey_enc( sig );
857     else
858         *ret_sig = sig;
859     return rc;
860 }
861
862