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