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