See ChangeLog: Wed Apr 28 13:03:03 CEST 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
459 /****************
460  * make a clear signature. note that opt.armor is not needed
461  */
462 int
463 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
464 {
465     armor_filter_context_t afx;
466     MD_HANDLE textmd = NULL;
467     IOBUF inp = NULL, out = NULL;
468     PACKET pkt;
469     int rc = 0;
470     SK_LIST sk_list = NULL;
471     SK_LIST sk_rover = NULL;
472     int old_style = opt.rfc1991;
473     int only_md5 = 0;
474
475     memset( &afx, 0, sizeof afx);
476     init_packet( &pkt );
477
478     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
479         goto leave;
480     if( !old_style )
481         old_style = only_old_style( sk_list );
482
483     /* prepare iobufs */
484     if( !(inp = iobuf_open(fname)) ) {
485         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
486                                         strerror(errno) );
487         rc = G10ERR_OPEN_FILE;
488         goto leave;
489     }
490
491     if( outfile ) {
492         if( !(out = iobuf_create( outfile )) ) {
493             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
494             rc = G10ERR_CREATE_FILE;
495             goto leave;
496         }
497         else if( opt.verbose )
498             log_info(_("writing to `%s'\n"), outfile );
499     }
500     else if( (rc = open_outfile( fname, 1, &out )) )
501         goto leave;
502
503     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n" );
504
505     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
506         PKT_secret_key *sk = sk_rover->sk;
507         if( hash_for(sk->pubkey_algo) == DIGEST_ALGO_MD5 )
508             only_md5 = 1;
509         else {
510             only_md5 = 0;
511             break;
512         }
513     }
514
515     if( old_style || only_md5 )
516         iobuf_writestr(out, "\n" );
517     else {
518         const char *s;
519         int any = 0;
520
521         iobuf_writestr(out, "Hash: " );
522         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
523             PKT_secret_key *sk = sk_rover->sk;
524             s = digest_algo_to_string( hash_for(sk->pubkey_algo) );
525             if( s ) {
526                 if( any )
527                     iobuf_put(out, ',' );
528                 iobuf_writestr(out, s );
529                 any = 1;
530             }
531         }
532         assert(any);
533         iobuf_writestr(out, "\n" );
534         if( opt.not_dash_escaped )
535             iobuf_writestr( out,
536                 "NotDashEscaped: You need GnuPG to verify this message\n" );
537         iobuf_writestr(out, "\n" );
538     }
539
540
541     textmd = md_open(0, 0);
542     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
543         PKT_secret_key *sk = sk_rover->sk;
544         md_enable(textmd, hash_for(sk->pubkey_algo));
545     }
546     /*md_start_debug( textmd, "sign" );*/
547     copy_clearsig_text( out, inp, textmd,
548                         !opt.not_dash_escaped, opt.escape_from );
549     /* fixme: check for read errors */
550
551     /* now write the armor */
552     afx.what = 2;
553     iobuf_push_filter( out, armor_filter, &afx );
554
555     /* loop over the secret certificates */
556     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
557         PKT_secret_key *sk;
558         PKT_signature *sig;
559         MD_HANDLE md;
560
561         sk = sk_rover->sk;
562
563         /* build the signature packet */
564         /* fixme: this code is duplicated above */
565         sig = m_alloc_clear( sizeof *sig );
566         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
567         keyid_from_sk( sk, sig->keyid );
568         sig->digest_algo = hash_for(sk->pubkey_algo);
569         sig->pubkey_algo = sk->pubkey_algo;
570         sig->timestamp = make_timestamp();
571         sig->sig_class = 0x01;
572
573         md = md_copy( textmd );
574         if( sig->version >= 4 ) {
575             build_sig_subpkt_from_sig( sig );
576             md_putc( md, sig->version );
577         }
578         md_putc( md, sig->sig_class );
579         if( sig->version < 4 ) {
580             u32 a = sig->timestamp;
581             md_putc( md, (a >> 24) & 0xff );
582             md_putc( md, (a >> 16) & 0xff );
583             md_putc( md, (a >>  8) & 0xff );
584             md_putc( md,  a        & 0xff );
585         }
586         else {
587             byte buf[6];
588             size_t n;
589
590             md_putc( md, sig->pubkey_algo );
591             md_putc( md, sig->digest_algo );
592             if( sig->hashed_data ) {
593                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
594                 md_write( md, sig->hashed_data, n+2 );
595                 n += 6;
596             }
597             else
598                 n = 6;
599             /* add some magic */
600             buf[0] = sig->version;
601             buf[1] = 0xff;
602             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
603             buf[3] = n >> 16;
604             buf[4] = n >>  8;
605             buf[5] = n;
606             md_write( md, buf, 6 );
607
608         }
609         md_final( md );
610
611         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
612         md_close( md );
613
614         if( !rc ) { /* and write it */
615             init_packet(&pkt);
616             pkt.pkttype = PKT_SIGNATURE;
617             pkt.pkt.signature = sig;
618             rc = build_packet( out, &pkt );
619             free_packet( &pkt );
620             if( rc )
621                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
622         }
623         if( rc )
624             goto leave;
625     }
626
627
628   leave:
629     if( rc )
630         iobuf_cancel(out);
631     else
632         iobuf_close(out);
633     iobuf_close(inp);
634     md_close( textmd );
635     release_sk_list( sk_list );
636     return rc;
637 }
638
639
640 /****************
641  * Create a signature packet for the given public key certificate
642  * and the user id and return it in ret_sig. User signature class SIGCLASS
643  * user-id is not used (and may be NULL if sigclass is 0x20)
644  * If digest_algo is 0 the function selects an appropriate one.
645  */
646 int
647 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
648                     PKT_user_id *uid, PKT_public_key *subpk,
649                     PKT_secret_key *sk,
650                     int sigclass, int digest_algo,
651                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
652                    )
653 {
654     PKT_signature *sig;
655     int rc=0;
656     MD_HANDLE md;
657
658     assert( (sigclass >= 0x10 && sigclass <= 0x13)
659             || sigclass == 0x20 || sigclass == 0x18
660             || sigclass == 0x30 || sigclass == 0x28 );
661     if( !digest_algo ) {
662         switch( sk->pubkey_algo ) {
663           case PUBKEY_ALGO_DSA: digest_algo = DIGEST_ALGO_SHA1; break;
664           case PUBKEY_ALGO_RSA_S:
665           case PUBKEY_ALGO_RSA: digest_algo = DIGEST_ALGO_MD5; break;
666           default:              digest_algo = DIGEST_ALGO_RMD160; break;
667         }
668     }
669     md = md_open( digest_algo, 0 );
670
671     /* hash the public key certificate and the user id */
672     hash_public_key( md, pk );
673     if( sigclass == 0x18 || sigclass == 0x28 ) { /* subkey binding/revocation*/
674         hash_public_key( md, subpk );
675     }
676     else if( sigclass != 0x20 ) {
677         if( sk->version >=4 ) {
678             byte buf[5];
679             buf[0] = 0xb4;            /* indicates a userid packet */
680             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
681             buf[2] = uid->len >> 16;
682             buf[3] = uid->len >>  8;
683             buf[4] = uid->len;
684             md_write( md, buf, 5 );
685         }
686         md_write( md, uid->name, uid->len );
687     }
688     /* and make the signature packet */
689     sig = m_alloc_clear( sizeof *sig );
690     sig->version = sk->version;
691     keyid_from_sk( sk, sig->keyid );
692     sig->pubkey_algo = sk->pubkey_algo;
693     sig->digest_algo = digest_algo;
694     sig->timestamp = make_timestamp();
695     sig->sig_class = sigclass;
696     if( sig->version >= 4 )
697         build_sig_subpkt_from_sig( sig );
698
699     if( sig->version >= 4 && mksubpkt )
700         rc = (*mksubpkt)( sig, opaque );
701
702     if( !rc ) {
703         if( sig->version >= 4 )
704             md_putc( md, sig->version );
705         md_putc( md, sig->sig_class );
706         if( sig->version < 4 ) {
707             u32 a = sig->timestamp;
708             md_putc( md, (a >> 24) & 0xff );
709             md_putc( md, (a >> 16) & 0xff );
710             md_putc( md, (a >>  8) & 0xff );
711             md_putc( md,  a        & 0xff );
712         }
713         else {
714             byte buf[6];
715             size_t n;
716
717             md_putc( md, sig->pubkey_algo );
718             md_putc( md, sig->digest_algo );
719             if( sig->hashed_data ) {
720                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
721                 md_write( md, sig->hashed_data, n+2 );
722                 n += 6;
723             }
724             else
725                 n = 6;
726             /* add some magic */
727             buf[0] = sig->version;
728             buf[1] = 0xff;
729             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
730             buf[3] = n >> 16;
731             buf[4] = n >>  8;
732             buf[5] = n;
733             md_write( md, buf, 6 );
734
735         }
736         md_final(md);
737
738         rc = complete_sig( sig, sk, md );
739     }
740
741     md_close( md );
742     if( rc )
743         free_seckey_enc( sig );
744     else
745         *ret_sig = sig;
746     return rc;
747 }
748
749