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