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