Finished the bulk of changes for gnupg 1.9. This included switching
[gnupg.git] / g10 / sign.c
1 /* sign.c - sign data
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include <unistd.h> /* need sleep() */
29
30 #include "options.h"
31 #include "packet.h"
32 #include "errors.h"
33 #include "iobuf.h"
34 #include "keydb.h"
35 #include "memory.h"
36 #include "util.h"
37 #include "main.h"
38 #include "filter.h"
39 #include "ttyio.h"
40 #include "trustdb.h"
41 #include "status.h"
42 #include "i18n.h"
43 #include "pkglue.h"
44
45 #ifdef HAVE_DOSISH_SYSTEM
46 #define LF "\r\n"
47 void __stdcall Sleep(ulong);
48 #define sleep(a)  Sleep((a)*1000)
49 #else
50 #define LF "\n"
51 #endif
52
53 static int recipient_digest_algo=0;
54
55 /****************
56  * Create a notation.  It is assumed that the stings in STRLIST
57  * are already checked to contain only printable data and have a valid
58  * NAME=VALUE format.
59  */
60 static void
61 mk_notation_and_policy( PKT_signature *sig,
62                         PKT_public_key *pk, PKT_secret_key *sk )
63 {
64     const char *string;
65     char *s=NULL;
66     byte *buf;
67     unsigned n1, n2;
68     STRLIST nd=NULL,pu=NULL;
69     struct expando_args args;
70
71     memset(&args,0,sizeof(args));
72     args.pk=pk;
73     args.sk=sk;
74
75     /* notation data */
76     if(IS_SIG(sig) && opt.sig_notation_data)
77       {
78         if(sig->version<4)
79           log_info("can't put notation data into v3 signatures\n");
80         else
81           nd=opt.sig_notation_data;
82       }
83     else if( IS_CERT(sig) && opt.cert_notation_data )
84       {
85         if(sig->version<4)
86           log_info("can't put notation data into v3 key signatures\n");
87         else
88           nd=opt.cert_notation_data;
89       }
90
91     for( ; nd; nd = nd->next ) {
92         char *expanded;
93
94         string = nd->d;
95         s = strchr( string, '=' );
96         if( !s )
97           BUG(); /* we have already parsed this */
98         n1 = s - string;
99         s++;
100
101         expanded=pct_expando(s,&args);
102         if(!expanded)
103           {
104             log_error(_("WARNING: unable to %%-expand notation "
105                         "(too large).  Using unexpanded.\n"));
106             expanded=xstrdup (s);
107           }
108
109         n2 = strlen(expanded);
110         buf = xmalloc ( 8 + n1 + n2 );
111         buf[0] = 0x80; /* human readable */
112         buf[1] = buf[2] = buf[3] = 0;
113         buf[4] = n1 >> 8;
114         buf[5] = n1;
115         buf[6] = n2 >> 8;
116         buf[7] = n2;
117         memcpy(buf+8, string, n1 );
118         memcpy(buf+8+n1, expanded, n2 );
119         build_sig_subpkt( sig, SIGSUBPKT_NOTATION
120                           | ((nd->flags & 1)? SIGSUBPKT_FLAG_CRITICAL:0),
121                           buf, 8+n1+n2 );
122         xfree (expanded);
123         xfree (buf);
124     }
125
126     if(opt.list_options&LIST_SHOW_NOTATION)
127       show_notation(sig,0,0);
128
129     /* set policy URL */
130     if( IS_SIG(sig) && opt.sig_policy_url )
131       {
132         if(sig->version<4)
133           log_info("can't put a policy URL into v3 signatures\n");
134         else
135           pu=opt.sig_policy_url;
136       }
137     else if( IS_CERT(sig) && opt.cert_policy_url )
138       {
139         if(sig->version<4)
140           log_info("can't put a policy URL into v3 key signatures\n");
141         else
142           pu=opt.cert_policy_url;
143       }
144
145     for(;pu;pu=pu->next)
146       {
147         string = pu->d;
148
149         s=pct_expando(string,&args);
150         if(!s)
151           {
152             log_error(_("WARNING: unable to %%-expand policy url "
153                         "(too large).  Using unexpanded.\n"));
154             s=xstrdup (string);
155           }
156
157         build_sig_subpkt(sig,SIGSUBPKT_POLICY|
158                          ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0),
159                          s,strlen(s));
160
161         xfree (s);
162       }
163
164     if(opt.list_options&LIST_SHOW_POLICY)
165       show_policy_url(sig,0,0);
166 }
167
168
169 /*
170  * Helper to hash a user ID packet.  
171  */
172 static void
173 hash_uid (MD_HANDLE md, int sigversion, const PKT_user_id *uid)
174 {
175     if ( sigversion >= 4 ) {
176         byte buf[5];
177
178         if(uid->attrib_data) {
179           buf[0] = 0xd1;                   /* indicates an attribute packet */
180           buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
181           buf[2] = uid->attrib_len >> 16;
182           buf[3] = uid->attrib_len >>  8;
183           buf[4] = uid->attrib_len;
184         }
185         else {
186           buf[0] = 0xb4;            /* indicates a userid packet */
187           buf[1] = uid->len >> 24;  /* always use 4 length bytes */
188           buf[2] = uid->len >> 16;
189           buf[3] = uid->len >>  8;
190           buf[4] = uid->len;
191         }
192         gcry_md_write( md, buf, 5 );
193     }
194
195     if(uid->attrib_data)
196       gcry_md_write (md, uid->attrib_data, uid->attrib_len );
197     else
198       gcry_md_write (md, uid->name, uid->len );
199 }
200
201
202 /*
203  * Helper to hash some parts from the signature
204  */
205 static void
206 hash_sigversion_to_magic (MD_HANDLE md, const PKT_signature *sig)
207 {
208     if (sig->version >= 4) 
209         gcry_md_putc (md, sig->version);
210     gcry_md_putc (md, sig->sig_class);
211     if (sig->version < 4) {
212         u32 a = sig->timestamp;
213         gcry_md_putc (md, (a >> 24) & 0xff );
214         gcry_md_putc (md, (a >> 16) & 0xff );
215         gcry_md_putc (md, (a >>  8) & 0xff );
216         gcry_md_putc (md,  a           & 0xff );
217     }
218     else {
219         byte buf[6];
220         size_t n;
221         
222         gcry_md_putc (md, sig->pubkey_algo);
223         gcry_md_putc (md, sig->digest_algo);
224         if (sig->hashed) {
225             n = sig->hashed->len;
226             gcry_md_putc (md, (n >> 8) );
227             gcry_md_putc (md,  n       );
228             gcry_md_write (md, sig->hashed->data, n );
229             n += 6;
230         }
231         else {
232             gcry_md_putc (md, 0);  /* always hash the length of the subpacket*/
233             gcry_md_putc (md, 0);
234             n = 6;
235         }
236         /* add some magic */
237         buf[0] = sig->version;
238         buf[1] = 0xff;
239         buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
240         buf[3] = n >> 16;
241         buf[4] = n >>  8;
242         buf[5] = n;
243         gcry_md_write (md, buf, 6);
244     }
245 }
246
247
248 static int
249 do_sign( PKT_secret_key *sk, PKT_signature *sig,
250          MD_HANDLE md, int digest_algo )
251 {
252     gcry_mpi_t frame;
253     byte *dp;
254     int rc;
255
256     if( sk->timestamp > sig->timestamp ) {
257         ulong d = sk->timestamp - sig->timestamp;
258         log_info( d==1 ? _("key has been created %lu second "
259                            "in future (time warp or clock problem)\n")
260                        : _("key has been created %lu seconds "
261                            "in future (time warp or clock problem)\n"), d );
262         if( !opt.ignore_time_conflict )
263             return GPG_ERR_TIME_CONFLICT;
264     }
265
266
267     print_pubkey_algo_note(sk->pubkey_algo);
268
269     if( !digest_algo )
270         digest_algo = gcry_md_get_algo(md);
271
272     print_digest_algo_note( digest_algo );
273     dp = gcry_md_read ( md, digest_algo );
274     sig->digest_algo = digest_algo;
275     sig->digest_start[0] = dp[0];
276     sig->digest_start[1] = dp[1];
277     frame = encode_md_value( sk->pubkey_algo, md,
278                              digest_algo, mpi_get_nbits(sk->skey[0]), 0 );
279     if (!frame)
280         return GPG_ERR_GENERAL;
281     rc = pk_sign( sk->pubkey_algo, sig->data, frame, sk->skey );
282     gcry_mpi_release (frame);
283     if (!rc && !opt.no_sig_create_check) {
284         /* check that the signature verification worked and nothing is
285          * fooling us e.g. by a bug in the signature create
286          * code or by deliberately introduced faults. */
287         PKT_public_key *pk = xcalloc (1,sizeof *pk);
288
289         if( get_pubkey( pk, sig->keyid ) )
290             rc = GPG_ERR_NO_PUBKEY;
291         else {
292             frame = encode_md_value (pk->pubkey_algo, md,
293                                      sig->digest_algo,
294                                      mpi_get_nbits(pk->pkey[0]), 0);
295             if (!frame)
296                 rc = GPG_ERR_GENERAL;
297             else
298                 rc = pk_verify (pk->pubkey_algo, frame,
299                                 sig->data, pk->pkey);
300             gcry_mpi_release (frame);
301         }
302         if (rc)
303             log_error (_("checking created signature failed: %s\n"),
304                          gpg_strerror (rc));
305         free_public_key (pk);
306     }
307     if( rc )
308         log_error(_("signing failed: %s\n"), gpg_strerror (rc) );
309     else {
310         if( opt.verbose ) {
311             char *ustr = get_user_id_string_printable (sig->keyid);
312             log_info(_("%s/%s signature from: \"%s\"\n"),
313                      gcry_pk_algo_name (sk->pubkey_algo),
314                      gcry_md_algo_name (sig->digest_algo),
315                      ustr );
316             xfree (ustr);
317         }
318     }
319     return rc;
320 }
321
322
323
324 int
325 complete_sig( PKT_signature *sig, PKT_secret_key *sk, MD_HANDLE md )
326 {
327     int rc=0;
328
329     if( !(rc=check_secret_key( sk, 0 )) )
330         rc = do_sign( sk, sig, md, 0 );
331     return rc;
332 }
333
334 static int
335 hash_for(int pubkey_algo, int packet_version )
336 {
337   if( opt.def_digest_algo )
338     return opt.def_digest_algo;
339   else if( recipient_digest_algo )
340     return recipient_digest_algo;
341   else if(PGP2 && pubkey_algo == PUBKEY_ALGO_RSA && packet_version < 4 )
342     {
343       /* Old-style PGP only understands MD5 */
344       return DIGEST_ALGO_MD5;
345     }
346   else if( pubkey_algo == PUBKEY_ALGO_DSA )
347     {
348       /* We need a 160-bit hash for DSA, so we can't just take the first
349          in the pref list */
350
351       if(opt.personal_digest_prefs)
352         {
353           prefitem_t *prefs;
354
355           for(prefs=opt.personal_digest_prefs;prefs->type;prefs++)
356             if(gcry_md_get_algo_dlen (prefs->value) == 20)
357               return prefs->value;
358         }
359
360       return DIGEST_ALGO_SHA1;
361     }
362   else if( opt.personal_digest_prefs )
363     {
364       /* It's not DSA, so we can use whatever the first hash algorithm
365          is in the pref list */
366       return opt.personal_digest_prefs[0].value;
367     }
368   else
369     return DEFAULT_DIGEST_ALGO;
370 }
371
372 static int
373 only_old_style( SK_LIST sk_list )
374 {
375     SK_LIST sk_rover = NULL;
376     int old_style = 0;
377
378     /* if there are only old style capable key we use the old sytle */
379     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
380         PKT_secret_key *sk = sk_rover->sk;
381         if( sk->pubkey_algo == PUBKEY_ALGO_RSA && sk->version < 4 )
382             old_style = 1;
383         else
384             return 0;
385     }
386     return old_style;
387 }
388
389
390 static void
391 print_status_sig_created ( PKT_secret_key *sk, PKT_signature *sig, int what )
392 {
393     byte array[MAX_FINGERPRINT_LEN], *p;
394     char buf[100+MAX_FINGERPRINT_LEN*2];
395     size_t i, n;
396
397     sprintf(buf, "%c %d %d %02x %lu ",
398             what, sig->pubkey_algo, sig->digest_algo, sig->sig_class,
399             (ulong)sig->timestamp );
400
401     fingerprint_from_sk( sk, array, &n );
402     p = buf + strlen(buf);
403     for(i=0; i < n ; i++ )
404         sprintf(p+2*i, "%02X", array[i] );
405
406     write_status_text( STATUS_SIG_CREATED, buf );
407 }
408
409
410 /*
411  * Loop over the secret certificates in SK_LIST and build the one pass
412  * signature packets.  OpenPGP says that the data should be bracket by
413  * the onepass-sig and signature-packet; so we build these onepass
414  * packet here in reverse order 
415  */
416 static int
417 write_onepass_sig_packets (SK_LIST sk_list, iobuf_t out, int sigclass )
418 {
419     int skcount;
420     SK_LIST sk_rover;
421
422     for (skcount=0, sk_rover=sk_list; sk_rover; sk_rover = sk_rover->next)
423         skcount++;
424
425     for (; skcount; skcount--) {
426         PKT_secret_key *sk;
427         PKT_onepass_sig *ops;
428         PACKET pkt;
429         int i, rc;
430         
431         for (i=0, sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
432             if (++i == skcount)
433                 break;
434         }
435
436         sk = sk_rover->sk;
437         ops = xcalloc (1,sizeof *ops);
438         ops->sig_class = sigclass;
439         ops->digest_algo = hash_for (sk->pubkey_algo, sk->version);
440         ops->pubkey_algo = sk->pubkey_algo;
441         keyid_from_sk (sk, ops->keyid);
442         ops->last = (skcount == 1);
443         
444         init_packet(&pkt);
445         pkt.pkttype = PKT_ONEPASS_SIG;
446         pkt.pkt.onepass_sig = ops;
447         rc = build_packet (out, &pkt);
448         free_packet (&pkt);
449         if (rc) {
450             log_error ("build onepass_sig packet failed: %s\n",
451                        gpg_strerror (rc));
452             return rc;
453         }
454     }
455
456     return 0;
457 }
458
459 /*
460  * Helper to write the plaintext (literal data) packet
461  */
462 static int
463 write_plaintext_packet (iobuf_t out, iobuf_t inp, const char *fname, int ptmode)
464 {
465     PKT_plaintext *pt = NULL;
466     u32 filesize;
467     int rc = 0;
468
469     if (!opt.no_literal) {
470         if (fname || opt.set_filename) {
471             char *s = make_basename (opt.set_filename? opt.set_filename
472                                                      : fname
473                                      /*, iobuf_get_real_fname(inp)*/);
474             pt = xmalloc (sizeof *pt + strlen(s) - 1);
475             pt->namelen = strlen (s);
476             memcpy (pt->name, s, pt->namelen);
477             xfree (s);
478         }
479         else { /* no filename */
480             pt = xmalloc (sizeof *pt - 1);
481             pt->namelen = 0;
482         }
483     }
484
485     /* try to calculate the length of the data */
486     if (fname && *fname && !(*fname=='-' && !fname[1])) {
487         if( !(filesize = iobuf_get_filelength(inp)) )
488             log_info (_("WARNING: `%s' is an empty file\n"), fname);
489
490         /* we can't yet encode the length of very large files,
491          * so we switch to partial length encoding in this case */
492         if (filesize >= IOBUF_FILELENGTH_LIMIT)
493             filesize = 0;
494
495         /* because the text_filter modifies the length of the
496          * data, it is not possible to know the used length
497          * without a double read of the file - to avoid that
498          * we simple use partial length packets.
499          */
500         if ( ptmode == 't' )
501             filesize = 0;
502     }
503     else {
504         filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
505     }
506
507     if (!opt.no_literal) {
508         PACKET pkt;
509
510         pt->timestamp = make_timestamp ();
511         pt->mode = ptmode;
512         pt->len = filesize;
513         pt->new_ctb = !pt->len && !RFC1991;
514         pt->buf = inp;
515         init_packet(&pkt);
516         pkt.pkttype = PKT_PLAINTEXT;
517         pkt.pkt.plaintext = pt;
518         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
519         if( (rc = build_packet (out, &pkt)) )
520             log_error ("build_packet(PLAINTEXT) failed: %s\n",
521                        gpg_strerror (rc) );
522         pt->buf = NULL;
523     }
524     else {
525         byte copy_buffer[4096];
526         int  bytes_copied;
527
528         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
529             if ( (rc=iobuf_write(out, copy_buffer, bytes_copied) )) {
530                 log_error ("copying input to output failed: %s\n",
531                            gpg_strerror (rc));
532                 break;
533             }
534         wipememory(copy_buffer,4096); /* burn buffer */
535     }
536     /* fixme: it seems that we never freed pt/pkt */
537     
538     return rc;
539 }
540
541 /*
542  * Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
543  * hash which will not be changes here.
544  */
545 static int
546 write_signature_packets (SK_LIST sk_list, iobuf_t out, MD_HANDLE hash,
547                          int sigclass, u32 timestamp, u32 duration,
548                          int status_letter)
549 {
550     SK_LIST sk_rover;
551
552     /* loop over the secret certificates */
553     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
554         PKT_secret_key *sk;
555         PKT_signature *sig;
556         MD_HANDLE md;
557         int rc;
558
559         sk = sk_rover->sk;
560
561         /* build the signature packet */
562         sig = xcalloc (1,sizeof *sig);
563         if(opt.force_v3_sigs || RFC1991)
564           sig->version=3;
565         else if(duration || opt.sig_policy_url || opt.sig_notation_data)
566           sig->version=4;
567         else
568           sig->version=sk->version;
569         keyid_from_sk (sk, sig->keyid);
570         sig->digest_algo = hash_for (sk->pubkey_algo, sk->version);
571         sig->pubkey_algo = sk->pubkey_algo;
572         if(timestamp)
573           sig->timestamp = timestamp;
574         else
575           sig->timestamp = make_timestamp();
576         if(duration)
577           sig->expiredate = sig->timestamp+duration;
578         sig->sig_class = sigclass;
579
580         gcry_md_copy (&md, hash);
581
582         if (sig->version >= 4)
583             build_sig_subpkt_from_sig (sig);
584         mk_notation_and_policy (sig, NULL, sk);
585
586         hash_sigversion_to_magic (md, sig);
587         gcry_md_final (md);
588
589         rc = do_sign( sk, sig, md, hash_for (sig->pubkey_algo, sk->version) );
590         gcry_md_close (md);
591
592         if( !rc ) { /* and write it */
593             PACKET pkt;
594
595             init_packet(&pkt);
596             pkt.pkttype = PKT_SIGNATURE;
597             pkt.pkt.signature = sig;
598             rc = build_packet (out, &pkt);
599             if (!rc && is_status_enabled()) {
600                 print_status_sig_created ( sk, sig, status_letter);
601             }
602             free_packet (&pkt);
603             if (rc)
604                 log_error ("build signature packet failed: %s\n",
605                            gpg_strerror (rc) );
606         }
607         if( rc )
608             return rc;;
609     }
610
611     return 0;
612 }
613
614 /****************
615  * Sign the files whose names are in FILENAME.
616  * If DETACHED has the value true,
617  * make a detached signature.  If FILENAMES->d is NULL read from stdin
618  * and ignore the detached mode.  Sign the file with all secret keys
619  * which can be taken from LOCUSR, if this is NULL, use the default one
620  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
621  * signed data for these users.
622  * If OUTFILE is not NULL; this file is used for output and the function
623  * does not ask for overwrite permission; output is then always
624  * uncompressed, non-armored and in binary mode.
625  */
626 int
627 sign_file( STRLIST filenames, int detached, STRLIST locusr,
628            int encryptflag, STRLIST remusr, const char *outfile )
629 {
630     const char *fname;
631     armor_filter_context_t afx;
632     compress_filter_context_t zfx;
633     md_filter_context_t mfx;
634     text_filter_context_t tfx;
635     progress_filter_context_t pfx;
636     encrypt_filter_context_t efx;
637     iobuf_t inp = NULL, out = NULL;
638     PACKET pkt;
639     int rc = 0;
640     PK_LIST pk_list = NULL;
641     SK_LIST sk_list = NULL;
642     SK_LIST sk_rover = NULL;
643     int multifile = 0;
644     u32 duration=0;
645
646     memset( &afx, 0, sizeof afx);
647     memset( &zfx, 0, sizeof zfx);
648     memset( &mfx, 0, sizeof mfx);
649     memset( &efx, 0, sizeof efx);
650     init_packet( &pkt );
651
652     if( filenames ) {
653         fname = filenames->d;
654         multifile = !!filenames->next;
655     }
656     else
657         fname = NULL;
658
659     if( fname && filenames->next && (!detached || encryptflag) )
660         log_bug("multiple files can only be detached signed");
661
662     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !RFC1991)
663       duration=ask_expire_interval(1);
664
665     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
666         goto leave;
667
668     if(PGP2 && !only_old_style(sk_list))
669       {
670         log_info(_("you can only detach-sign with PGP 2.x style keys "
671                    "while in --pgp2 mode\n"));
672         compliance_failure();
673       }
674
675     if(encryptflag && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
676       goto leave;
677
678     /* prepare iobufs */
679     if( multifile )  /* have list of filenames */
680         inp = NULL; /* we do it later */
681     else {
682         if( !(inp = iobuf_open(fname)) ) {
683             rc = gpg_error_from_errno (errno);
684             log_error("can't open %s: %s\n", fname? fname: "[stdin]",
685                       strerror(errno) );
686             goto leave;
687         }
688
689         handle_progress (&pfx, inp, fname);
690     }
691
692     if( outfile ) {
693         if( !(out = iobuf_create( outfile )) ) {
694             rc = gpg_error_from_errno (errno);
695             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
696             goto leave;
697         }
698         else if( opt.verbose )
699             log_info(_("writing to `%s'\n"), outfile );
700     }
701     else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
702         goto leave;
703
704     /* prepare to calculate the MD over the input */
705     if( opt.textmode && !outfile && !multifile )
706       {
707         memset( &tfx, 0, sizeof tfx);
708         iobuf_push_filter( inp, text_filter, &tfx );
709       }
710
711     gcry_md_open (&mfx.md, 0, 0);
712
713    /* If we're encrypting and signing, it is reasonable to pick the
714        hash algorithm to use out of the recepient key prefs. */
715     if(pk_list)
716       {
717         if(opt.def_digest_algo)
718           {
719             if(!opt.expert &&
720                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
721                                       opt.def_digest_algo,
722                                       NULL)!=opt.def_digest_algo)
723           log_info(_("forcing digest algorithm %s (%d) "
724                      "violates recipient preferences\n"),
725                    gcry_md_algo_name (opt.def_digest_algo),
726                    opt.def_digest_algo);
727           }
728         else
729           {
730             int hashlen=0,algo;
731
732             /* Of course, if the recipient asks for something
733                unreasonable (like a non-160-bit hash for DSA, for
734                example), then don't do it.  Check all sk's - if any
735                are DSA, then the hash must be 160-bit.  In the future
736                this can be more complex with different hashes for each
737                sk, but so long as there is only one signing algorithm
738                with hash restrictions, this is ok. -dms */
739
740             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
741               if(sk_rover->sk->pubkey_algo==PUBKEY_ALGO_DSA)
742                 hashlen=20;
743
744             if((algo=
745                 select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,
746                                        hashlen?&hashlen:NULL))>0)
747               recipient_digest_algo=algo;
748           }
749       }
750
751     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
752         PKT_secret_key *sk = sk_rover->sk;
753         gcry_md_enable (mfx.md, hash_for(sk->pubkey_algo, sk->version ));
754     }
755
756     if( !multifile )
757         iobuf_push_filter( inp, md_filter, &mfx );
758
759     if( detached && !encryptflag && !RFC1991 )
760         afx.what = 2;
761
762     if( opt.armor && !outfile  )
763         iobuf_push_filter( out, armor_filter, &afx );
764
765     if( encryptflag ) {
766         efx.pk_list = pk_list;
767         /* fixme: set efx.cfx.datalen if known */
768         iobuf_push_filter( out, encrypt_filter, &efx );
769     }
770
771     if( opt.compress && !outfile && ( !detached || opt.compress_sigs) )
772       {
773         int compr_algo=opt.def_compress_algo;
774
775         /* If not forced by user */
776         if(compr_algo==-1)
777           {
778             /* If we're not encrypting, then select_algo_from_prefs
779                will fail and we'll end up with the default.  If we are
780                encrypting, select_algo_from_prefs cannot fail since
781                there is an assumed preference for uncompressed data.
782                Still, if it did fail, we'll also end up with the
783                default. */
784  
785             if((compr_algo=
786                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
787               compr_algo=default_compress_algo();
788           }
789         else if(!opt.expert && pk_list
790                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
791                                           compr_algo,NULL)!=compr_algo)
792           log_info(_("forcing compression algorithm %s (%d) "
793                      "violates recipient preferences\n"),
794                    compress_algo_to_string(compr_algo),compr_algo);
795
796         /* algo 0 means no compression */
797         if( compr_algo )
798           {
799             zfx.algo = compr_algo;
800             iobuf_push_filter( out, compress_filter, &zfx );
801           }
802       }
803
804     /* Write the one-pass signature packets if needed */
805     if (!detached && !RFC1991) {
806         rc = write_onepass_sig_packets (sk_list, out,
807                                         opt.textmode && !outfile ? 0x01:0x00);
808         if (rc)
809             goto leave;
810     }
811
812     /* setup the inner packet */
813     if( detached ) {
814         if( multifile ) {
815             STRLIST sl;
816
817             if( opt.verbose )
818                 log_info(_("signing:") );
819             /* must walk reverse trough this list */
820             for( sl = strlist_last(filenames); sl;
821                         sl = strlist_prev( filenames, sl ) ) {
822                 if( !(inp = iobuf_open(sl->d)) ) {
823                     rc = gpg_error_from_errno (errno);
824                     log_error(_("can't open %s: %s\n"),
825                                             sl->d, strerror(errno) );
826                     goto leave;
827                 }
828                 handle_progress (&pfx, inp, sl->d);
829                 if( opt.verbose )
830                     fprintf(stderr, " `%s'", sl->d );
831                 if(opt.textmode)
832                   {
833                     memset( &tfx, 0, sizeof tfx);
834                     iobuf_push_filter( inp, text_filter, &tfx );
835                   }
836                 iobuf_push_filter( inp, md_filter, &mfx );
837                 while( iobuf_get(inp) != -1 )
838                     ;
839                 iobuf_close(inp); inp = NULL;
840             }
841             if( opt.verbose )
842                 putc( '\n', stderr );
843         }
844         else {
845             /* read, so that the filter can calculate the digest */
846             while( iobuf_get(inp) != -1 )
847                 ;
848         }
849     }
850     else {
851         rc = write_plaintext_packet (out, inp, fname,
852                                      opt.textmode && !outfile ? 't':'b');
853     }
854
855     /* catch errors from above */
856     if (rc)
857         goto leave;
858
859     /* write the signatures */
860     rc = write_signature_packets (sk_list, out, mfx.md,
861                                   opt.textmode && !outfile? 0x01 : 0x00,
862                                   0, duration, detached ? 'D':'S');
863     if( rc )
864         goto leave;
865
866
867   leave:
868     if( rc )
869         iobuf_cancel(out);
870     else {
871         iobuf_close(out);
872         if (encryptflag)
873             write_status( STATUS_END_ENCRYPTION );
874     }
875     iobuf_close(inp);
876     gcry_md_close ( mfx.md );
877     release_sk_list( sk_list );
878     release_pk_list( pk_list );
879     recipient_digest_algo=0;
880     return rc;
881 }
882
883
884
885 /****************
886  * make a clear signature. note that opt.armor is not needed
887  */
888 int
889 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
890 {
891     armor_filter_context_t afx;
892     progress_filter_context_t pfx;
893     MD_HANDLE textmd = NULL;
894     iobuf_t inp = NULL, out = NULL;
895     PACKET pkt;
896     int rc = 0;
897     SK_LIST sk_list = NULL;
898     SK_LIST sk_rover = NULL;
899     int old_style = RFC1991;
900     int only_md5 = 0;
901     u32 duration=0;
902
903     memset( &afx, 0, sizeof afx);
904     init_packet( &pkt );
905
906     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !RFC1991)
907       duration=ask_expire_interval(1);
908
909     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
910         goto leave;
911
912     if( !old_style && !duration )
913         old_style = only_old_style( sk_list );
914
915     if(PGP2 && !only_old_style(sk_list))
916       {
917         log_info(_("you can only clearsign with PGP 2.x style keys "
918                    "while in --pgp2 mode\n"));
919         compliance_failure();
920       }
921
922     /* prepare iobufs */
923     if( !(inp = iobuf_open(fname)) ) {
924         rc = gpg_error_from_errno (errno);
925         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
926                                         strerror(errno) );
927         goto leave;
928     }
929     handle_progress (&pfx, inp, fname);
930
931     if( outfile ) {
932         if( !(out = iobuf_create( outfile )) ) {
933             rc = gpg_error_from_errno (errno);
934             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
935             goto leave;
936         }
937         else if( opt.verbose )
938             log_info(_("writing to `%s'\n"), outfile );
939     }
940     else if( (rc = open_outfile( fname, 1, &out )) )
941         goto leave;
942
943     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
944
945     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
946         PKT_secret_key *sk = sk_rover->sk;
947         if( hash_for(sk->pubkey_algo, sk->version) == DIGEST_ALGO_MD5 )
948             only_md5 = 1;
949         else {
950             only_md5 = 0;
951             break;
952         }
953     }
954
955     if( !(old_style && only_md5) ) {
956         const char *s;
957         int any = 0;
958         byte hashs_seen[256];
959
960         memset( hashs_seen, 0, sizeof hashs_seen );
961         iobuf_writestr(out, "Hash: " );
962         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
963             PKT_secret_key *sk = sk_rover->sk;
964             int i = hash_for(sk->pubkey_algo, sk->version);
965
966             if( !hashs_seen[ i & 0xff ] ) {
967                 s = gcry_md_algo_name (i);
968                 if( s ) {
969                     hashs_seen[ i & 0xff ] = 1;
970                     if( any )
971                         iobuf_put(out, ',' );
972                     iobuf_writestr(out, s );
973                     any = 1;
974                 }
975             }
976         }
977         assert(any);
978         iobuf_writestr(out, LF );
979     }
980
981     if( opt.not_dash_escaped )
982       iobuf_writestr( out,
983                   "NotDashEscaped: You need GnuPG to verify this message" LF );
984     iobuf_writestr(out, LF );
985
986     gcry_md_open (&textmd, 0, 0);
987     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
988         PKT_secret_key *sk = sk_rover->sk;
989         gcry_md_enable (textmd, hash_for(sk->pubkey_algo, sk->version));
990     }
991     if ( DBG_HASHING )
992         gcry_md_start_debug ( textmd, "clearsign" );
993     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
994                         opt.escape_from, (old_style && only_md5) );
995     /* fixme: check for read errors */
996
997     /* now write the armor */
998     afx.what = 2;
999     iobuf_push_filter( out, armor_filter, &afx );
1000
1001     /* write the signatures */
1002     rc=write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C');
1003     if( rc )
1004         goto leave;
1005
1006   leave:
1007     if( rc )
1008         iobuf_cancel(out);
1009     else
1010         iobuf_close(out);
1011     iobuf_close(inp);
1012     gcry_md_close ( textmd );
1013     release_sk_list( sk_list );
1014     return rc;
1015 }
1016
1017 /*
1018  * Sign and conventionally encrypt the given file.
1019  * FIXME: Far too much code is duplicated - revamp the whole file.
1020  */
1021 int
1022 sign_symencrypt_file (const char *fname, STRLIST locusr)
1023 {
1024     armor_filter_context_t afx;
1025     progress_filter_context_t pfx;
1026     compress_filter_context_t zfx;
1027     md_filter_context_t mfx;
1028     text_filter_context_t tfx;
1029     cipher_filter_context_t cfx;
1030     iobuf_t inp = NULL, out = NULL;
1031     PACKET pkt;
1032     STRING2KEY *s2k = NULL;
1033     int rc = 0;
1034     SK_LIST sk_list = NULL;
1035     SK_LIST sk_rover = NULL;
1036     int algo;
1037     u32 duration=0;
1038
1039     memset( &afx, 0, sizeof afx);
1040     memset( &zfx, 0, sizeof zfx);
1041     memset( &mfx, 0, sizeof mfx);
1042     memset( &tfx, 0, sizeof tfx);
1043     memset( &cfx, 0, sizeof cfx);
1044     init_packet( &pkt );
1045
1046     if(opt.ask_sig_expire && !opt.force_v3_sigs && !opt.batch && !RFC1991)
1047       duration=ask_expire_interval(1);
1048
1049     rc = build_sk_list (locusr, &sk_list, 1, PUBKEY_USAGE_SIG);
1050     if (rc) 
1051         goto leave;
1052
1053     /* prepare iobufs */
1054     inp = iobuf_open(fname);
1055     if( !inp ) {
1056         rc = gpg_error_from_errno (errno);
1057         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
1058                                         strerror(errno) );
1059         goto leave;
1060     }
1061     handle_progress (&pfx, inp, fname);
1062
1063     /* prepare key */
1064     s2k = xcalloc (1, sizeof *s2k );
1065     s2k->mode = RFC1991? 0:opt.s2k_mode;
1066     s2k->hash_algo = opt.s2k_digest_algo;
1067
1068     algo = default_cipher_algo();
1069     if (!opt.quiet || !opt.batch)
1070         log_info (_("%s encryption will be used\n"),
1071                     gcry_cipher_algo_name (algo) );
1072     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, NULL);
1073
1074     if (!cfx.dek || !cfx.dek->keylen) {
1075         rc = gpg_error (GPG_ERR_INV_PASSPHRASE);
1076         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1077         goto leave;
1078     }
1079
1080     /* now create the outfile */
1081     rc = open_outfile (fname, opt.armor? 1:0, &out);
1082     if (rc)
1083         goto leave;
1084
1085     /* prepare to calculate the MD over the input */
1086     if (opt.textmode)
1087         iobuf_push_filter (inp, text_filter, &tfx);
1088     gcry_md_open (&mfx.md, 0, 0);
1089
1090     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
1091         PKT_secret_key *sk = sk_rover->sk;
1092         gcry_md_enable (mfx.md, hash_for (sk->pubkey_algo, sk->version ));
1093     }
1094
1095     iobuf_push_filter (inp, md_filter, &mfx);
1096
1097     /* Push armor output filter */
1098     if (opt.armor)
1099         iobuf_push_filter (out, armor_filter, &afx);
1100
1101     /* Write the symmetric key packet */
1102     /*(current filters: armor)*/
1103     if (!RFC1991) {
1104         PKT_symkey_enc *enc = xcalloc (1, sizeof *enc );
1105         enc->version = 4;
1106         enc->cipher_algo = cfx.dek->algo;
1107         enc->s2k = *s2k;
1108         pkt.pkttype = PKT_SYMKEY_ENC;
1109         pkt.pkt.symkey_enc = enc;
1110         if( (rc = build_packet( out, &pkt )) )
1111             log_error("build symkey packet failed: %s\n", gpg_strerror (rc) );
1112         xfree (enc);
1113     }
1114
1115     /* Push the encryption filter */
1116     iobuf_push_filter( out, cipher_filter, &cfx );
1117
1118     /* Push the Zip filter */
1119     if (opt.compress && default_compress_algo())
1120       {
1121         zfx.algo = default_compress_algo();
1122         iobuf_push_filter( out, compress_filter, &zfx );
1123       }
1124
1125     /* Write the one-pass signature packets */
1126     /*(current filters: zip - encrypt - armor)*/
1127     if (!RFC1991) {
1128         rc = write_onepass_sig_packets (sk_list, out,
1129                                         opt.textmode? 0x01:0x00);
1130         if (rc)
1131             goto leave;
1132     }
1133
1134     /* Pipe data through all filters; i.e. write the signed stuff */
1135     /*(current filters: zip - encrypt - armor)*/
1136     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1137     if (rc)
1138         goto leave;
1139     
1140     /* Write the signatures */
1141     /*(current filters: zip - encrypt - armor)*/
1142     rc = write_signature_packets (sk_list, out, mfx.md,
1143                                   opt.textmode? 0x01 : 0x00,
1144                                   0, duration, 'S');
1145     if( rc )
1146         goto leave;
1147
1148
1149   leave:
1150     if( rc )
1151         iobuf_cancel(out);
1152     else {
1153         iobuf_close(out);
1154         write_status( STATUS_END_ENCRYPTION );
1155     }
1156     iobuf_close(inp);
1157     release_sk_list( sk_list );
1158     gcry_md_close ( mfx.md );
1159     xfree (cfx.dek);
1160     xfree (s2k);
1161     return rc;
1162 }
1163
1164
1165 /****************
1166  * Create a signature packet for the given public key certificate and
1167  * the user id and return it in ret_sig. User signature class SIGCLASS
1168  * user-id is not used (and may be NULL if sigclass is 0x20) If
1169  * DIGEST_ALGO is 0 the function selects an appropriate one.
1170  * SIGVERSION gives the minimal required signature packet version;
1171  * this is needed so that special properties like local sign are not
1172  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1173  * the timestamp to use for the signature. 0 means "now" */
1174 int
1175 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1176                     PKT_user_id *uid, PKT_public_key *subpk,
1177                     PKT_secret_key *sk,
1178                     int sigclass, int digest_algo,
1179                     int sigversion, u32 timestamp, u32 duration,
1180                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
1181                    )
1182 {
1183     PKT_signature *sig;
1184     int rc=0;
1185     MD_HANDLE md;
1186
1187     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1188             || sigclass == 0x20 || sigclass == 0x18
1189             || sigclass == 0x30 || sigclass == 0x28 );
1190
1191     if (opt.force_v4_certs)
1192         sigversion = 4;
1193
1194     if (sigversion < sk->version)
1195         sigversion = sk->version;
1196
1197     /* If you are making a signature on a v4 key using your v3 key, it
1198        doesn't make sense to generate a v3 sig.  After all, no v3-only
1199        PGP implementation could understand the v4 key in the first
1200        place.  Note that this implies that a signature on an attribute
1201        uid is usually going to be v4 as well, since they are not
1202        generally found on v3 keys. */
1203     if (sigversion < pk->version)
1204         sigversion = pk->version;
1205
1206     if( !digest_algo )
1207       {
1208         /* Basically, this means use SHA1 always unless it's a v3 RSA
1209            key making a v3 cert (use MD5), or the user specified
1210            something (use whatever they said).  They still must use a
1211            160-bit hash with DSA, or the signature will fail.  Note
1212            that this still allows the caller of make_keysig_packet to
1213            override the user setting if it must. */
1214
1215         if(opt.cert_digest_algo)
1216           digest_algo=opt.cert_digest_algo;
1217         else if((sk->pubkey_algo==PUBKEY_ALGO_RSA ||
1218                  sk->pubkey_algo==PUBKEY_ALGO_RSA_S) &&
1219                 pk->version<4 && sigversion < 4)
1220           digest_algo = DIGEST_ALGO_MD5;
1221         else
1222           digest_algo = DIGEST_ALGO_SHA1;
1223       }
1224
1225     gcry_md_open (&md, digest_algo, 0 );
1226
1227     /* hash the public key certificate and the user id */
1228     hash_public_key( md, pk );
1229     if( sigclass == 0x18 || sigclass == 0x28 ) { /* subkey binding/revocation*/
1230         hash_public_key( md, subpk );
1231     }
1232     else if( sigclass != 0x1F && sigclass != 0x20 ) {
1233         hash_uid (md, sigversion, uid);
1234     }
1235     /* and make the signature packet */
1236     sig = xcalloc (1, sizeof *sig );
1237     sig->version = sigversion;
1238     sig->flags.exportable=1;
1239     sig->flags.revocable=1;
1240     keyid_from_sk( sk, sig->keyid );
1241     sig->pubkey_algo = sk->pubkey_algo;
1242     sig->digest_algo = digest_algo;
1243     if(timestamp)
1244       sig->timestamp=timestamp;
1245     else
1246       sig->timestamp=make_timestamp();
1247     if(duration)
1248       sig->expiredate=sig->timestamp+duration;
1249     sig->sig_class = sigclass;
1250     if( sig->version >= 4 )
1251         build_sig_subpkt_from_sig( sig );
1252     mk_notation_and_policy( sig, pk, sk );
1253
1254     /* Crucial that the call to mksubpkt comes LAST before the calls
1255        to finalize the sig as that makes it possible for the mksubpkt
1256        function to get a reliable pointer to the subpacket area. */
1257     if( sig->version >= 4 && mksubpkt )
1258         rc = (*mksubpkt)( sig, opaque );
1259
1260     if( !rc ) {
1261         hash_sigversion_to_magic (md, sig);
1262         gcry_md_final (md);
1263
1264         rc = complete_sig( sig, sk, md );
1265     }
1266
1267     gcry_md_close ( md );
1268     if( rc )
1269         free_seckey_enc( sig );
1270     else
1271         *ret_sig = sig;
1272     return rc;
1273 }
1274
1275
1276
1277 /****************
1278  * Create a new signature packet based on an existing one.
1279  * Only user ID signatures are supported for now.
1280  * TODO: Merge this with make_keysig_packet.
1281  */
1282 int
1283 update_keysig_packet( PKT_signature **ret_sig,
1284                       PKT_signature *orig_sig,
1285                       PKT_public_key *pk,
1286                       PKT_user_id *uid, 
1287                       PKT_public_key *subpk,
1288                       PKT_secret_key *sk,
1289                       int (*mksubpkt)(PKT_signature *, void *),
1290                       void *opaque
1291                    )
1292 {
1293     PKT_signature *sig;
1294     int rc=0;
1295     MD_HANDLE md;
1296
1297     if ((!orig_sig || !pk || !sk)
1298         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1299         || (orig_sig->sig_class == 0x18 && !subpk))
1300       return GPG_ERR_GENERAL;
1301
1302     gcry_md_open (&md, orig_sig->digest_algo, 0);
1303
1304     /* hash the public key certificate and the user id */
1305     hash_public_key( md, pk );
1306
1307     if( orig_sig->sig_class == 0x18 )
1308       hash_public_key( md, subpk );
1309     else
1310       hash_uid (md, orig_sig->version, uid);
1311
1312     /* create a new signature packet */
1313     sig = copy_signature (NULL, orig_sig);
1314
1315     /* We need to create a new timestamp so that new sig expiration
1316        calculations are done correctly... */
1317     sig->timestamp=make_timestamp();
1318
1319     /* ... but we won't make a timestamp earlier than the existing
1320        one. */
1321     while(sig->timestamp<=orig_sig->timestamp)
1322       {
1323         sleep(1);
1324         sig->timestamp=make_timestamp();
1325       }
1326
1327     /* Note that already expired sigs will remain expired (with a
1328        duration of 0) since build-packet.c:build_sig_subpkt_from_sig
1329        detects this case. */
1330
1331     if( sig->version >= 4 )
1332       {
1333         /* Put the updated timestamp into the sig.  Note that this
1334            will automagically lower any sig expiration dates to
1335            correctly correspond to the differences in the timestamps
1336            (i.e. the duration will shrink). */
1337         build_sig_subpkt_from_sig( sig );
1338
1339         if (mksubpkt)
1340           rc = (*mksubpkt)(sig, opaque);
1341       }
1342
1343     if (!rc) {
1344         hash_sigversion_to_magic (md, sig);
1345         gcry_md_final (md);
1346
1347         rc = complete_sig( sig, sk, md );
1348     }
1349
1350     gcry_md_close (md);
1351     if( rc )
1352         free_seckey_enc (sig);
1353     else
1354         *ret_sig = sig;
1355     return rc;
1356 }