See ChangeLog: Fri Jul 14 19:38:23 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          s_skey = SEXP_CONS( SEXP_NEW( "private-key", 0 ),
62                           gcry_sexp_vlist( SEXP_NEW( "dsa", 3 ),
63                           gcry_sexp_new_name_mpi( "p", skey[0] ),
64                           gcry_sexp_new_name_mpi( "q", skey[1] ),
65                           gcry_sexp_new_name_mpi( "g", skey[2] ),
66                           gcry_sexp_new_name_mpi( "y", skey[3] ),
67                           gcry_sexp_new_name_mpi( "x", skey[4] ),
68                           NULL ));
69     }
70     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
71         s_skey = SEXP_CONS( SEXP_NEW( "private-key", 0 ),
72                           gcry_sexp_vlist( SEXP_NEW( "elg", 3 ),
73                           gcry_sexp_new_name_mpi( "p", skey[0] ),
74                           gcry_sexp_new_name_mpi( "g", skey[1] ),
75                           gcry_sexp_new_name_mpi( "y", skey[2] ),
76                           gcry_sexp_new_name_mpi( "x", skey[3] ),
77                           NULL ));
78     }
79     else
80         return GPGERR_PUBKEY_ALGO;
81
82     /* put hash into a S-Exp s_hash */
83     s_hash = gcry_sexp_new_mpi( hash );
84
85     rc = gcry_pk_sign( &s_sig, s_hash, s_skey );
86     gcry_sexp_release( s_hash );
87     gcry_sexp_release( s_skey );
88
89     if( rc )
90         ;
91     else {
92         list = gcry_sexp_find_token( s_sig, "r" , 0 );
93         assert( list );
94         data[0] = gcry_sexp_cdr_mpi( list, 0 );
95         assert( data[0] );
96         list = gcry_sexp_find_token( s_sig, "s" , 0 );
97         assert( list );
98         data[1] = gcry_sexp_cdr_mpi( list, 0 );
99         assert( data[1] );
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 )
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 )
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
271 /****************
272  * Sign the files whose names are in FILENAME.
273  * If DETACHED has the value true,
274  * make a detached signature.  If FILENAMES->d is NULL read from stdin
275  * and ignore the detached mode.  Sign the file with all secret keys
276  * which can be taken from LOCUSR, if this is NULL, use the default one
277  * If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
278  * signed data for these users.
279  * If OUTFILE is not NULL; this file is used for output and the function
280  * does not ask for overwrite permission; output is then always
281  * uncompressed, non-armored and in binary mode.
282  */
283 int
284 sign_file( STRLIST filenames, int detached, STRLIST locusr,
285            int encrypt, STRLIST remusr, const char *outfile )
286 {
287     const char *fname;
288     armor_filter_context_t afx;
289     compress_filter_context_t zfx;
290     md_filter_context_t mfx;
291     text_filter_context_t tfx;
292     encrypt_filter_context_t efx;
293     IOBUF inp = NULL, out = NULL;
294     PACKET pkt;
295     PKT_plaintext *pt = NULL;
296     u32 filesize;
297     int rc = 0;
298     PK_LIST pk_list = NULL;
299     SK_LIST sk_list = NULL;
300     SK_LIST sk_rover = NULL;
301     int multifile = 0;
302     int old_style = opt.rfc1991;
303     int compr_algo = -1; /* unknown */
304
305
306     memset( &afx, 0, sizeof afx);
307     memset( &zfx, 0, sizeof zfx);
308     memset( &mfx, 0, sizeof mfx);
309     memset( &tfx, 0, sizeof tfx);
310     memset( &efx, 0, sizeof efx);
311     init_packet( &pkt );
312
313     if( filenames ) {
314         fname = filenames->d;
315         multifile = !!filenames->next;
316     }
317     else
318         fname = NULL;
319
320     if( fname && filenames->next && (!detached || encrypt) )
321         log_bug("multiple files can only be detached signed");
322
323     if( (rc=build_sk_list( locusr, &sk_list, 1, GCRY_PK_USAGE_SIGN )) )
324         goto leave;
325     if( !old_style )
326         old_style = only_old_style( sk_list );
327
328     if( encrypt ) {
329         if( (rc=build_pk_list( remusr, &pk_list, GCRY_PK_USAGE_ENCR )) )
330             goto leave;
331         if( !old_style )
332             compr_algo = select_algo_from_prefs( pk_list, PREFTYPE_COMPR );
333     }
334
335     /* prepare iobufs */
336     if( multifile )  /* have list of filenames */
337         inp = NULL; /* we do it later */
338     else if( !(inp = iobuf_open(fname)) ) {
339         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
340                                         strerror(errno) );
341         rc = GPGERR_OPEN_FILE;
342         goto leave;
343     }
344
345     if( outfile ) {
346         if( !(out = iobuf_create( outfile )) ) {
347             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
348             rc = GPGERR_CREATE_FILE;
349             goto leave;
350         }
351         else if( opt.verbose )
352             log_info(_("writing to `%s'\n"), outfile );
353     }
354     else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
355         goto leave;
356
357     /* prepare to calculate the MD over the input */
358     if( opt.textmode && !outfile )
359         iobuf_push_filter( inp, text_filter, &tfx );
360     if( !(mfx.md = gcry_md_open(0, 0)))
361         BUG();
362
363     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
364         PKT_secret_key *sk = sk_rover->sk;
365         gcry_md_enable(mfx.md, hash_for(sk->pubkey_algo));
366     }
367
368     if( !multifile )
369         iobuf_push_filter( inp, md_filter, &mfx );
370
371     if( detached && !encrypt && !opt.rfc1991 )
372         afx.what = 2;
373
374     if( opt.armor && !outfile  )
375         iobuf_push_filter( out, armor_filter, &afx );
376   #ifdef ENABLE_COMMENT_PACKETS
377     else {
378         write_comment( out, "#created by GNUPG v" VERSION " ("
379                                             PRINTABLE_OS_NAME ")");
380         if( opt.comment_string )
381             write_comment( out, opt.comment_string );
382     }
383   #endif
384     if( encrypt ) {
385         efx.pk_list = pk_list;
386         /* fixme: set efx.cfx.datalen if known */
387         iobuf_push_filter( out, encrypt_filter, &efx );
388     }
389
390     if( opt.compress && !outfile && ( !detached || opt.compress_sigs) ) {
391         if( !compr_algo )
392             ; /* don't use compression */
393         else {
394             if( old_style
395                 || compr_algo == 1
396                 || (compr_algo == -1 && !encrypt) )
397                 zfx.algo = 1; /* use the non optional algorithm */
398             iobuf_push_filter( out, compress_filter, &zfx );
399         }
400     }
401
402     if( !detached && !old_style ) {
403         int skcount=0;
404         /* loop over the secret certificates and build headers
405          * The specs now say that the data should be bracket by
406          * the onepass-sig and signature-packet; so we must build it
407          * here in reverse order */
408         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
409             skcount++;
410         for( ; skcount; skcount-- ) {
411             PKT_secret_key *sk;
412             PKT_onepass_sig *ops;
413             int i = 0;
414
415             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
416                 if( ++i == skcount )
417                     break;
418
419             sk = sk_rover->sk;
420             ops = gcry_xcalloc( 1, sizeof *ops );
421             ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
422             ops->digest_algo = hash_for(sk->pubkey_algo);
423             ops->pubkey_algo = sk->pubkey_algo;
424             keyid_from_sk( sk, ops->keyid );
425             ops->last = skcount == 1;
426
427             init_packet(&pkt);
428             pkt.pkttype = PKT_ONEPASS_SIG;
429             pkt.pkt.onepass_sig = ops;
430             rc = build_packet( out, &pkt );
431             free_packet( &pkt );
432             if( rc ) {
433                 log_error("build onepass_sig packet failed: %s\n",
434                                                         gpg_errstr(rc));
435                 goto leave;
436             }
437         }
438     }
439
440     /* setup the inner packet */
441     if( detached ) {
442         if( multifile ) {
443             STRLIST sl;
444
445             if( opt.verbose )
446                 log_info(_("signing:") );
447             /* must walk reverse trough this list */
448             for( sl = strlist_last(filenames); sl;
449                         sl = strlist_prev( filenames, sl ) ) {
450                 if( !(inp = iobuf_open(sl->d)) ) {
451                     log_error(_("can't open %s: %s\n"),
452                                             sl->d, strerror(errno) );
453                     rc = GPGERR_OPEN_FILE;
454                     goto leave;
455                 }
456                 if( opt.verbose )
457                     fprintf(stderr, " `%s'", sl->d );
458                 iobuf_push_filter( inp, md_filter, &mfx );
459                 while( iobuf_get(inp) != -1 )
460                     ;
461                 iobuf_close(inp); inp = NULL;
462             }
463             if( opt.verbose )
464                 putc( '\n', stderr );
465         }
466         else {
467             /* read, so that the filter can calculate the digest */
468             while( iobuf_get(inp) != -1 )
469                 ;
470         }
471     }
472     else {
473         if (!opt.no_literal) {
474             if( fname || opt.set_filename ) {
475                 char *s = make_basename( opt.set_filename ? opt.set_filename : fname );
476                 pt = gcry_xmalloc( sizeof *pt + strlen(s) - 1 );
477                 pt->namelen = strlen(s);
478                 memcpy(pt->name, s, pt->namelen );
479                 gcry_free(s);
480             }
481             else { /* no filename */
482                 pt = gcry_xmalloc( sizeof *pt - 1 );
483                 pt->namelen = 0;
484             }
485         }
486
487         if( fname ) {
488             if( !(filesize = iobuf_get_filelength(inp)) )
489                 log_info(_("WARNING: `%s' is an empty file\n"), fname );
490
491             /* because the text_filter modifies the length of the
492              * data, it is not possible to know the used length
493              * without a double read of the file - to avoid that
494              * we simple use partial length packets.
495              */
496             if( opt.textmode && !outfile )
497                 filesize = 0;
498         }
499         else
500             filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
501
502         if (!opt.no_literal) {
503             pt->timestamp = make_timestamp();
504             pt->mode = opt.textmode && !outfile ? 't':'b';
505             pt->len = filesize;
506             pt->new_ctb = !pt->len && !opt.rfc1991;
507             pt->buf = inp;
508             pkt.pkttype = PKT_PLAINTEXT;
509             pkt.pkt.plaintext = pt;
510             /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
511             if( (rc = build_packet( out, &pkt )) )
512                 log_error("build_packet(PLAINTEXT) failed: %s\n", gpg_errstr(rc) );
513             pt->buf = NULL;
514         }
515         else {
516             byte copy_buffer[4096];
517             int  bytes_copied;
518             while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
519                 if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
520                     rc = GPGERR_WRITE_FILE;
521                     log_error("copying input to output failed: %s\n", gpg_errstr(rc));
522                     break;
523                 }
524             memset(copy_buffer, 0, 4096); /* burn buffer */
525         }
526     }
527
528     /* catch errors from above blocks */
529     if (rc)
530         goto leave;
531
532     /* loop over the secret certificates */
533     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
534         PKT_secret_key *sk;
535         PKT_signature *sig;
536         GCRY_MD_HD md;
537
538         sk = sk_rover->sk;
539
540         /* build the signature packet */
541         /* fixme: this code is partly duplicated in make_keysig_packet */
542         sig = gcry_xcalloc( 1, sizeof *sig );
543         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
544         keyid_from_sk( sk, sig->keyid );
545         sig->digest_algo = hash_for(sk->pubkey_algo);
546         sig->pubkey_algo = sk->pubkey_algo;
547         sig->timestamp = make_timestamp();
548         sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
549
550         md = gcry_md_copy( mfx.md );
551         if( !md )
552             BUG();
553
554         if( sig->version >= 4 ) {
555             build_sig_subpkt_from_sig( sig );
556             gcry_md_putc( md, sig->version );
557         }
558
559         mk_notation_and_policy( sig );
560
561         gcry_md_putc( md, sig->sig_class );
562         if( sig->version < 4 ) {
563             u32 a = sig->timestamp;
564             gcry_md_putc( md, (a >> 24) & 0xff );
565             gcry_md_putc( md, (a >> 16) & 0xff );
566             gcry_md_putc( md, (a >>  8) & 0xff );
567             gcry_md_putc( md,  a        & 0xff );
568         }
569         else {
570             byte buf[6];
571             size_t n;
572
573             gcry_md_putc( md, sig->pubkey_algo );
574             gcry_md_putc( md, sig->digest_algo );
575             if( sig->hashed_data ) {
576                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
577                 gcry_md_write( md, sig->hashed_data, n+2 );
578                 n += 6;
579             }
580             else {
581                 gcry_md_putc( md, 0 );  /* always hash the length of the subpacket*/
582                 gcry_md_putc( md, 0 );
583                 n = 6;
584             }
585             /* add some magic */
586             buf[0] = sig->version;
587             buf[1] = 0xff;
588             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
589             buf[3] = n >> 16;
590             buf[4] = n >>  8;
591             buf[5] = n;
592             gcry_md_write( md, buf, 6 );
593
594         }
595         gcry_md_final( md );
596
597         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
598         gcry_md_close( md );
599
600         if( !rc ) { /* and write it */
601             init_packet(&pkt);
602             pkt.pkttype = PKT_SIGNATURE;
603             pkt.pkt.signature = sig;
604             rc = build_packet( out, &pkt );
605             if( !rc && is_status_enabled() ) {
606                 print_status_sig_created ( sk, sig, detached ? 'D':'S');
607             }
608             free_packet( &pkt );
609             if( rc )
610                 log_error("build signature packet failed: %s\n", gpg_errstr(rc) );
611         }
612         if( rc )
613             goto leave;
614
615     }
616
617
618   leave:
619     if( rc )
620         iobuf_cancel(out);
621     else
622         iobuf_close(out);
623     iobuf_close(inp);
624     gcry_md_close( mfx.md );
625     release_sk_list( sk_list );
626     release_pk_list( pk_list );
627     return rc;
628 }
629
630
631
632 /****************
633  * make a clear signature. note that opt.armor is not needed
634  */
635 int
636 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
637 {
638     armor_filter_context_t afx;
639     GCRY_MD_HD textmd = NULL;
640     IOBUF inp = NULL, out = NULL;
641     PACKET pkt;
642     int rc = 0;
643     SK_LIST sk_list = NULL;
644     SK_LIST sk_rover = NULL;
645     int old_style = opt.rfc1991;
646     int only_md5 = 0;
647
648     memset( &afx, 0, sizeof afx);
649     init_packet( &pkt );
650
651     if( (rc=build_sk_list( locusr, &sk_list, 1, GCRY_PK_USAGE_SIGN )) )
652         goto leave;
653     if( !old_style )
654         old_style = only_old_style( sk_list );
655
656     /* prepare iobufs */
657     if( !(inp = iobuf_open(fname)) ) {
658         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
659                                         strerror(errno) );
660         rc = GPGERR_OPEN_FILE;
661         goto leave;
662     }
663
664     if( outfile ) {
665         if( !(out = iobuf_create( outfile )) ) {
666             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
667             rc = GPGERR_CREATE_FILE;
668             goto leave;
669         }
670         else if( opt.verbose )
671             log_info(_("writing to `%s'\n"), outfile );
672     }
673     else if( (rc = open_outfile( fname, 1, &out )) )
674         goto leave;
675
676     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
677
678     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
679         PKT_secret_key *sk = sk_rover->sk;
680         if( hash_for(sk->pubkey_algo) == GCRY_MD_MD5 )
681             only_md5 = 1;
682         else {
683             only_md5 = 0;
684             break;
685         }
686     }
687
688     if( old_style && only_md5 )
689         iobuf_writestr(out, "\n" );
690     else {
691         int any = 0;
692         byte hashs_seen[256];
693
694         memset( hashs_seen, 0, sizeof hashs_seen );
695         iobuf_writestr(out, "Hash: " );
696         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
697             PKT_secret_key *sk = sk_rover->sk;
698             int i = hash_for(sk->pubkey_algo);
699
700             if( !hashs_seen[ i & 0xff ] ) {
701                 if( !openpgp_md_test_algo( i ) ) {
702                     hashs_seen[ i & 0xff ] = 1;
703                     if( any )
704                         iobuf_put(out, ',' );
705                     iobuf_writestr(out, gcry_md_algo_name( i ) );
706                     any = 1;
707                 }
708             }
709         }
710         assert(any);
711         iobuf_writestr(out, "\n" );
712         if( opt.not_dash_escaped )
713             iobuf_writestr( out,
714                 "NotDashEscaped: You need GnuPG to verify this message\n" );
715         iobuf_writestr(out, "\n" );
716     }
717
718
719     textmd = gcry_md_open(0, 0);
720     if( !textmd )
721         BUG();
722     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
723         PKT_secret_key *sk = sk_rover->sk;
724         gcry_md_enable(textmd, hash_for(sk->pubkey_algo));
725     }
726     if ( DBG_HASHING )
727         gcry_md_start_debug( textmd, "clearsign" );
728     copy_clearsig_text( out, inp, textmd,
729                         !opt.not_dash_escaped, opt.escape_from, old_style );
730     /* fixme: check for read errors */
731
732     /* now write the armor */
733     afx.what = 2;
734     iobuf_push_filter( out, armor_filter, &afx );
735
736     /* loop over the secret certificates */
737     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
738         PKT_secret_key *sk;
739         PKT_signature *sig;
740         GCRY_MD_HD md;
741
742         sk = sk_rover->sk;
743
744         /* build the signature packet */
745         /* fixme: this code is duplicated above */
746         sig = gcry_xcalloc( 1, sizeof *sig );
747         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
748         keyid_from_sk( sk, sig->keyid );
749         sig->digest_algo = hash_for(sk->pubkey_algo);
750         sig->pubkey_algo = sk->pubkey_algo;
751         sig->timestamp = make_timestamp();
752         sig->sig_class = 0x01;
753
754         md = gcry_md_copy( textmd );
755         if( !md )
756             BUG();
757         if( sig->version >= 4 ) {
758             build_sig_subpkt_from_sig( sig );
759             gcry_md_putc( md, sig->version );
760         }
761
762         mk_notation_and_policy( sig );
763
764         gcry_md_putc( md, sig->sig_class );
765         if( sig->version < 4 ) {
766             u32 a = sig->timestamp;
767             gcry_md_putc( md, (a >> 24) & 0xff );
768             gcry_md_putc( md, (a >> 16) & 0xff );
769             gcry_md_putc( md, (a >>  8) & 0xff );
770             gcry_md_putc( md,  a        & 0xff );
771         }
772         else {
773             byte buf[6];
774             size_t n;
775
776             gcry_md_putc( md, sig->pubkey_algo );
777             gcry_md_putc( md, sig->digest_algo );
778             if( sig->hashed_data ) {
779                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
780                 gcry_md_write( md, sig->hashed_data, n+2 );
781                 n += 6;
782             }
783             else {
784                 gcry_md_putc( md, 0 );  /* always hash the length of the subpacket*/
785                 gcry_md_putc( md, 0 );
786                 n = 6;
787             }
788             /* add some magic */
789             buf[0] = sig->version;
790             buf[1] = 0xff;
791             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
792             buf[3] = n >> 16;
793             buf[4] = n >>  8;
794             buf[5] = n;
795             gcry_md_write( md, buf, 6 );
796
797         }
798         gcry_md_final( md );
799
800         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
801         gcry_md_close( md );
802
803         if( !rc ) { /* and write it */
804             init_packet(&pkt);
805             pkt.pkttype = PKT_SIGNATURE;
806             pkt.pkt.signature = sig;
807             rc = build_packet( out, &pkt );
808             if( !rc && is_status_enabled() ) {
809                 print_status_sig_created ( sk, sig, 'C');
810             }
811             free_packet( &pkt );
812             if( rc )
813                 log_error("build signature packet failed: %s\n", gpg_errstr(rc) );
814         }
815         if( rc )
816             goto leave;
817     }
818
819
820   leave:
821     if( rc )
822         iobuf_cancel(out);
823     else
824         iobuf_close(out);
825     iobuf_close(inp);
826     gcry_md_close( textmd );
827     release_sk_list( sk_list );
828     return rc;
829 }
830
831
832 /****************
833  * Create a signature packet for the given public key certificate
834  * and the user id and return it in ret_sig. User signature class SIGCLASS
835  * user-id is not used (and may be NULL if sigclass is 0x20)
836  * If digest_algo is 0 the function selects an appropriate one.
837  */
838 int
839 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
840                     PKT_user_id *uid, PKT_public_key *subpk,
841                     PKT_secret_key *sk,
842                     int sigclass, int digest_algo,
843                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
844                    )
845 {
846     PKT_signature *sig;
847     int rc=0;
848     GCRY_MD_HD md;
849
850     assert( (sigclass >= 0x10 && sigclass <= 0x13)
851             || sigclass == 0x20 || sigclass == 0x18
852             || sigclass == 0x30 || sigclass == 0x28 );
853     if( !digest_algo ) {
854         switch( sk->pubkey_algo ) {
855           case GCRY_PK_DSA: digest_algo = GCRY_MD_SHA1; break;
856           case GCRY_PK_RSA_S:
857           case GCRY_PK_RSA: digest_algo = GCRY_MD_MD5; break;
858           default:              digest_algo = GCRY_MD_RMD160; break;
859         }
860     }
861     if( !(md = gcry_md_open( digest_algo, 0 )))
862         BUG();
863
864     /* hash the public key certificate and the user id */
865     hash_public_key( md, pk );
866     if( sigclass == 0x18 || sigclass == 0x28 ) { /* subkey binding/revocation*/
867         hash_public_key( md, subpk );
868     }
869     else if( sigclass != 0x20 ) {
870         if( sk->version >=4 ) {
871             byte buf[5];
872             buf[0] = 0xb4;            /* indicates a userid packet */
873             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
874             buf[2] = uid->len >> 16;
875             buf[3] = uid->len >>  8;
876             buf[4] = uid->len;
877             gcry_md_write( md, buf, 5 );
878         }
879         gcry_md_write( md, uid->name, uid->len );
880     }
881     /* and make the signature packet */
882     sig = gcry_xcalloc( 1, sizeof *sig );
883     sig->version = sk->version;
884     keyid_from_sk( sk, sig->keyid );
885     sig->pubkey_algo = sk->pubkey_algo;
886     sig->digest_algo = digest_algo;
887     sig->timestamp = make_timestamp();
888     sig->sig_class = sigclass;
889     if( sig->version >= 4 )
890         build_sig_subpkt_from_sig( sig );
891
892     if( sig->version >= 4 && mksubpkt )
893         rc = (*mksubpkt)( sig, opaque );
894
895     if( !rc ) {
896         mk_notation_and_policy( sig );
897         if( sig->version >= 4 )
898             gcry_md_putc( md, sig->version );
899         gcry_md_putc( md, sig->sig_class );
900         if( sig->version < 4 ) {
901             u32 a = sig->timestamp;
902             gcry_md_putc( md, (a >> 24) & 0xff );
903             gcry_md_putc( md, (a >> 16) & 0xff );
904             gcry_md_putc( md, (a >>  8) & 0xff );
905             gcry_md_putc( md,  a        & 0xff );
906         }
907         else {
908             byte buf[6];
909             size_t n;
910
911             gcry_md_putc( md, sig->pubkey_algo );
912             gcry_md_putc( md, sig->digest_algo );
913             if( sig->hashed_data ) {
914                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
915                 gcry_md_write( md, sig->hashed_data, n+2 );
916                 n += 6;
917             }
918             else {
919                 gcry_md_putc( md, 0 );  /* always hash the length of the subpacket*/
920                 gcry_md_putc( md, 0 );
921                 n = 6;
922             }
923             /* add some magic */
924             buf[0] = sig->version;
925             buf[1] = 0xff;
926             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
927             buf[3] = n >> 16;
928             buf[4] = n >>  8;
929             buf[5] = n;
930             gcry_md_write( md, buf, 6 );
931
932         }
933         gcry_md_final(md);
934
935         rc = complete_sig( sig, sk, md );
936     }
937
938     gcry_md_close( md );
939     if( rc )
940         free_seckey_enc( sig );
941     else
942         *ret_sig = sig;
943     return rc;
944 }
945
946