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