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