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