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