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