See ChangeLog: Tue Mar 2 10:38:42 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
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     text_filter_context_t tfx;
467     MD_HANDLE textmd = NULL;
468     IOBUF inp = NULL, out = NULL;
469     PACKET pkt;
470     int rc = 0;
471     SK_LIST sk_list = NULL;
472     SK_LIST sk_rover = NULL;
473     int old_style = opt.rfc1991;
474     int only_md5 = 0;
475     int c;
476
477     memset( &afx, 0, sizeof afx);
478     memset( &tfx, 0, sizeof tfx);
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     tfx.clearsign = 1;
551     tfx.not_dash_escaped = opt.not_dash_escaped;
552     tfx.escape_from = opt.escape_from;
553     tfx.md = textmd;
554     iobuf_push_filter( inp, text_filter, &tfx );
555     /* read input and write it to the output.  The textfilter handles
556      * the calculation of the hash and the dash escaping */
557     while( (c=iobuf_get(inp)) != -1 )  {
558         if( iobuf_put(out, c) == -1 ) {
559             rc = G10ERR_WRITE_FILE;
560             goto leave;
561         }
562     }
563     /* fixme: check for read errors */
564
565     /* now write the armor */
566     afx.what = 2;
567     iobuf_push_filter( out, armor_filter, &afx );
568
569     /* loop over the secret certificates */
570     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
571         PKT_secret_key *sk;
572         PKT_signature *sig;
573         MD_HANDLE md;
574
575         sk = sk_rover->sk;
576
577         /* build the signature packet */
578         /* fixme: this code is duplicated above */
579         sig = m_alloc_clear( sizeof *sig );
580         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
581         keyid_from_sk( sk, sig->keyid );
582         sig->digest_algo = hash_for(sk->pubkey_algo);
583         sig->pubkey_algo = sk->pubkey_algo;
584         sig->timestamp = make_timestamp();
585         sig->sig_class = 0x01;
586
587         md = md_copy( textmd );
588         if( sig->version >= 4 ) {
589             build_sig_subpkt_from_sig( sig );
590             md_putc( md, sig->version );
591         }
592         md_putc( md, sig->sig_class );
593         if( sig->version < 4 ) {
594             u32 a = sig->timestamp;
595             md_putc( md, (a >> 24) & 0xff );
596             md_putc( md, (a >> 16) & 0xff );
597             md_putc( md, (a >>  8) & 0xff );
598             md_putc( md,  a        & 0xff );
599         }
600         else {
601             byte buf[6];
602             size_t n;
603
604             md_putc( md, sig->pubkey_algo );
605             md_putc( md, sig->digest_algo );
606             if( sig->hashed_data ) {
607                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
608                 md_write( md, sig->hashed_data, n+2 );
609                 n += 6;
610             }
611             else
612                 n = 6;
613             /* add some magic */
614             buf[0] = sig->version;
615             buf[1] = 0xff;
616             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
617             buf[3] = n >> 16;
618             buf[4] = n >>  8;
619             buf[5] = n;
620             md_write( md, buf, 6 );
621
622         }
623         md_final( md );
624
625         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
626         md_close( md );
627
628         if( !rc ) { /* and write it */
629             init_packet(&pkt);
630             pkt.pkttype = PKT_SIGNATURE;
631             pkt.pkt.signature = sig;
632             rc = build_packet( out, &pkt );
633             free_packet( &pkt );
634             if( rc )
635                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
636         }
637         if( rc )
638             goto leave;
639     }
640
641
642   leave:
643     if( rc )
644         iobuf_cancel(out);
645     else
646         iobuf_close(out);
647     iobuf_close(inp);
648     md_close( textmd );
649     release_sk_list( sk_list );
650     return rc;
651 }
652
653
654 /****************
655  * Create a signature packet for the given public key certificate
656  * and the user id and return it in ret_sig. User signature class SIGCLASS
657  * user-id is not used (and may be NULL if sigclass is 0x20)
658  * If digest_algo is 0 the function selects an appropriate one.
659  */
660 int
661 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
662                     PKT_user_id *uid, PKT_public_key *subpk,
663                     PKT_secret_key *sk,
664                     int sigclass, int digest_algo,
665                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
666                    )
667 {
668     PKT_signature *sig;
669     int rc=0;
670     MD_HANDLE md;
671
672     assert( (sigclass >= 0x10 && sigclass <= 0x13)
673             || sigclass == 0x20 || sigclass == 0x18 );
674     if( !digest_algo ) {
675         switch( sk->pubkey_algo ) {
676           case PUBKEY_ALGO_DSA: digest_algo = DIGEST_ALGO_SHA1; break;
677           case PUBKEY_ALGO_RSA_S:
678           case PUBKEY_ALGO_RSA: digest_algo = DIGEST_ALGO_MD5; break;
679           default:              digest_algo = DIGEST_ALGO_RMD160; break;
680         }
681     }
682     md = md_open( digest_algo, 0 );
683
684     /* hash the public key certificate and the user id */
685     hash_public_key( md, pk );
686     if( sigclass == 0x18 ) { /* subkey binding */
687         hash_public_key( md, subpk );
688     }
689     else if( sigclass != 0x20 ) {
690         if( sk->version >=4 ) {
691             byte buf[5];
692             buf[0] = 0xb4;            /* indicates a userid packet */
693             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
694             buf[2] = uid->len >> 16;
695             buf[3] = uid->len >>  8;
696             buf[4] = uid->len;
697             md_write( md, buf, 5 );
698         }
699         md_write( md, uid->name, uid->len );
700     }
701     /* and make the signature packet */
702     sig = m_alloc_clear( sizeof *sig );
703     sig->version = sk->version;
704     keyid_from_sk( sk, sig->keyid );
705     sig->pubkey_algo = sk->pubkey_algo;
706     sig->digest_algo = digest_algo;
707     sig->timestamp = make_timestamp();
708     sig->sig_class = sigclass;
709     if( sig->version >= 4 )
710         build_sig_subpkt_from_sig( sig );
711
712     if( sig->version >= 4 && mksubpkt )
713         rc = (*mksubpkt)( sig, opaque );
714
715     if( !rc ) {
716         if( sig->version >= 4 )
717             md_putc( md, sig->version );
718         md_putc( md, sig->sig_class );
719         if( sig->version < 4 ) {
720             u32 a = sig->timestamp;
721             md_putc( md, (a >> 24) & 0xff );
722             md_putc( md, (a >> 16) & 0xff );
723             md_putc( md, (a >>  8) & 0xff );
724             md_putc( md,  a        & 0xff );
725         }
726         else {
727             byte buf[6];
728             size_t n;
729
730             md_putc( md, sig->pubkey_algo );
731             md_putc( md, sig->digest_algo );
732             if( sig->hashed_data ) {
733                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
734                 md_write( md, sig->hashed_data, n+2 );
735                 n += 6;
736             }
737             else
738                 n = 6;
739             /* add some magic */
740             buf[0] = sig->version;
741             buf[1] = 0xff;
742             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
743             buf[3] = n >> 16;
744             buf[4] = n >>  8;
745             buf[5] = n;
746             md_write( md, buf, 6 );
747
748         }
749         md_final(md);
750
751         rc = complete_sig( sig, sk, md );
752     }
753
754     md_close( md );
755     if( rc )
756         free_seckey_enc( sig );
757     else
758         *ret_sig = sig;
759     return rc;
760 }
761
762