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