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