Decryption and signi via agent is now implemented.
[gnupg.git] / g10 / sign.c
1 /* sign.c - sign data
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2007, 2010 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 3 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, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "gpg.h"
29 #include "options.h"
30 #include "packet.h"
31 #include "status.h"
32 #include "iobuf.h"
33 #include "keydb.h"
34 #include "util.h"
35 #include "main.h"
36 #include "filter.h"
37 #include "ttyio.h"
38 #include "trustdb.h"
39 #include "status.h"
40 #include "i18n.h"
41 #include "pkglue.h"
42 #include "sysutils.h"
43 #include "call-agent.h"
44
45
46 #ifdef HAVE_DOSISH_SYSTEM
47 #define LF "\r\n"
48 #else
49 #define LF "\n"
50 #endif
51
52 static int recipient_digest_algo=0;
53
54 /****************
55  * Create notations and other stuff.  It is assumed that the stings in
56  * STRLIST are already checked to contain only printable data and have
57  * a valid NAME=VALUE format.
58  */
59 static void
60 mk_notation_policy_etc (PKT_signature *sig,
61                         PKT_public_key *pk, PKT_public_key *pksk)
62 {
63     const char *string;
64     char *s=NULL;
65     strlist_t pu=NULL;
66     struct notation *nd=NULL;
67     struct expando_args args;
68
69     assert(sig->version>=4);
70
71     memset(&args,0,sizeof(args));
72     args.pk=pk;
73     args.pksk=pksk;
74
75     /* notation data */
76     if(IS_SIG(sig) && opt.sig_notations)
77       nd=opt.sig_notations;
78     else if( IS_CERT(sig) && opt.cert_notations )
79       nd=opt.cert_notations;
80
81     if(nd)
82       {
83         struct notation *i;
84
85         for(i=nd;i;i=i->next)
86           {
87             i->altvalue=pct_expando(i->value,&args);
88             if(!i->altvalue)
89               log_error(_("WARNING: unable to %%-expand notation "
90                           "(too large).  Using unexpanded.\n"));
91           }
92
93         keygen_add_notations(sig,nd);
94
95         for(i=nd;i;i=i->next)
96           {
97             xfree(i->altvalue);
98             i->altvalue=NULL;
99           }
100       }
101
102     /* set policy URL */
103     if( IS_SIG(sig) && opt.sig_policy_url )
104       pu=opt.sig_policy_url;
105     else if( IS_CERT(sig) && opt.cert_policy_url )
106       pu=opt.cert_policy_url;
107
108     for(;pu;pu=pu->next)
109       {
110         string = pu->d;
111
112         s=pct_expando(string,&args);
113         if(!s)
114           {
115             log_error(_("WARNING: unable to %%-expand policy URL "
116                         "(too large).  Using unexpanded.\n"));
117             s=xstrdup(string);
118           }
119
120         build_sig_subpkt(sig,SIGSUBPKT_POLICY|
121                          ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0),
122                          s,strlen(s));
123
124         xfree(s);
125       }
126
127     /* preferred keyserver URL */
128     if( IS_SIG(sig) && opt.sig_keyserver_url )
129       pu=opt.sig_keyserver_url;
130
131     for(;pu;pu=pu->next)
132       {
133         string = pu->d;
134
135         s=pct_expando(string,&args);
136         if(!s)
137           {
138             log_error(_("WARNING: unable to %%-expand preferred keyserver URL"
139                         " (too large).  Using unexpanded.\n"));
140             s=xstrdup(string);
141           }
142
143         build_sig_subpkt(sig,SIGSUBPKT_PREF_KS|
144                          ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0),
145                          s,strlen(s));
146
147         xfree(s);
148       }
149 }
150
151
152 /*
153  * Helper to hash a user ID packet.  
154  */
155 static void
156 hash_uid (gcry_md_hd_t md, int sigversion, const PKT_user_id *uid)
157 {
158     if ( sigversion >= 4 ) {
159         byte buf[5];
160
161         if(uid->attrib_data) {
162           buf[0] = 0xd1;                   /* indicates an attribute packet */
163           buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
164           buf[2] = uid->attrib_len >> 16;
165           buf[3] = uid->attrib_len >>  8;
166           buf[4] = uid->attrib_len;
167         }
168         else {
169           buf[0] = 0xb4;            /* indicates a userid packet */
170           buf[1] = uid->len >> 24;  /* always use 4 length bytes */
171           buf[2] = uid->len >> 16;
172           buf[3] = uid->len >>  8;
173           buf[4] = uid->len;
174         }
175         gcry_md_write( md, buf, 5 );
176     }
177
178     if(uid->attrib_data)
179       gcry_md_write (md, uid->attrib_data, uid->attrib_len );
180     else
181       gcry_md_write (md, uid->name, uid->len );
182 }
183
184
185 /*
186  * Helper to hash some parts from the signature
187  */
188 static void
189 hash_sigversion_to_magic (gcry_md_hd_t md, const PKT_signature *sig)
190 {
191     if (sig->version >= 4) 
192         gcry_md_putc (md, sig->version);
193     gcry_md_putc (md, sig->sig_class);
194     if (sig->version < 4) {
195         u32 a = sig->timestamp;
196         gcry_md_putc (md, (a >> 24) & 0xff );
197         gcry_md_putc (md, (a >> 16) & 0xff );
198         gcry_md_putc (md, (a >>  8) & 0xff );
199         gcry_md_putc (md,  a           & 0xff );
200     }
201     else {
202         byte buf[6];
203         size_t n;
204         
205         gcry_md_putc (md, sig->pubkey_algo);
206         gcry_md_putc (md, sig->digest_algo);
207         if (sig->hashed) {
208             n = sig->hashed->len;
209             gcry_md_putc (md, (n >> 8) );
210             gcry_md_putc (md,  n       );
211             gcry_md_write (md, sig->hashed->data, n );
212             n += 6;
213         }
214         else {
215             gcry_md_putc (md, 0);  /* always hash the length of the subpacket*/
216             gcry_md_putc (md, 0);
217             n = 6;
218         }
219         /* add some magic */
220         buf[0] = sig->version;
221         buf[1] = 0xff;
222         buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
223         buf[3] = n >> 16;
224         buf[4] = n >>  8;
225         buf[5] = n;
226         gcry_md_write (md, buf, 6);
227     }
228 }
229
230
231 static gcry_mpi_t
232 mpi_from_sexp (gcry_sexp_t sexp, const char * item)
233 {
234   gcry_sexp_t list;
235   gcry_mpi_t data;
236   
237   list = gcry_sexp_find_token (sexp, item, 0);
238   assert (list);
239   data = gcry_sexp_nth_mpi (list, 1, 0);
240   assert (data);
241   gcry_sexp_release (list);
242   return data;
243 }
244
245
246 static int
247 do_sign (PKT_public_key *pksk, PKT_signature *sig,
248          gcry_md_hd_t md, int mdalgo)
249 {
250   gpg_error_t err;
251   gcry_mpi_t frame;
252   byte *dp;
253
254   if (pksk->timestamp > sig->timestamp )
255     {
256       ulong d = pksk->timestamp - sig->timestamp;
257       log_info (d==1 ? _("key has been created %lu second "
258                          "in future (time warp or clock problem)\n")
259                 : _("key has been created %lu seconds "
260                     "in future (time warp or clock problem)\n"), d );
261       if (!opt.ignore_time_conflict)
262         return gpg_error (GPG_ERR_TIME_CONFLICT);
263     }
264
265   
266   print_pubkey_algo_note (pksk->pubkey_algo);
267
268   if (!mdalgo)
269     mdalgo = gcry_md_get_algo (md);
270
271   print_digest_algo_note (mdalgo);
272   dp = gcry_md_read  (md, mdalgo);
273   sig->digest_algo = mdalgo;
274   sig->digest_start[0] = dp[0];
275   sig->digest_start[1] = dp[1];
276   sig->data[0] = NULL;
277   sig->data[1] = NULL;
278
279 #warning fixme: Use the agent for the card
280 /*     if (pksk->is_protected && pksk->protect.s2k.mode == 1002)  */
281 /*       {  */
282 /* #ifdef ENABLE_CARD_SUPPORT */
283 /*         unsigned char *rbuf; */
284 /*         size_t rbuflen; */
285 /*         char *snbuf; */
286         
287 /*         snbuf = serialno_and_fpr_from_sk (sk->protect.iv, */
288 /*                                           sk->protect.ivlen, sk); */
289 /*         rc = agent_scd_pksign (snbuf, digest_algo, */
290 /*                                gcry_md_read (md, digest_algo), */
291 /*                                gcry_md_get_algo_dlen (digest_algo), */
292 /*                                &rbuf, &rbuflen); */
293 /*         xfree (snbuf); */
294 /*         if (!rc) */
295 /*           { */
296 /*             if (gcry_mpi_scan (&sig->data[0], GCRYMPI_FMT_USG, */
297 /*                                rbuf, rbuflen, NULL)) */
298 /*               BUG (); */
299 /*             xfree (rbuf); */
300 /*           } */
301 /* #else */
302 /*         return gpg_error (GPG_ERR_NOT_SUPPORTED); */
303 /* #endif /\* ENABLE_CARD_SUPPORT *\/ */
304 /*       } */
305 /*     else  */
306   if (1)
307     {
308       char *hexgrip;
309       
310       err = hexkeygrip_from_pk (pksk, &hexgrip);
311       if (!err)
312         {
313           char *desc;
314           gcry_sexp_t s_sigval;
315           
316           /* FIXME: desc = gpgsm_format_keydesc (cert); */
317           desc = xtrystrdup ("FIXME: Format a description");
318           
319           err = agent_pksign (NULL/*ctrl*/, hexgrip, desc, 
320                               dp, gcry_md_get_algo_dlen (mdalgo), mdalgo,
321                               &s_sigval);
322           
323           xfree (desc);
324      
325           if (err)
326             ;
327           else if (pksk->pubkey_algo == GCRY_PK_RSA
328                    || pksk->pubkey_algo == GCRY_PK_RSA_S)
329             sig->data[0] = mpi_from_sexp (s_sigval, "s");
330           else
331             {
332               sig->data[0] = mpi_from_sexp (s_sigval, "r");
333               sig->data[1] = mpi_from_sexp (s_sigval, "s");
334             }
335       
336           gcry_sexp_release (s_sigval);
337         }
338       xfree (hexgrip);
339     }
340
341   /* Check that the signature verification worked and nothing is
342    * fooling us e.g. by a bug in the signature create code or by
343    * deliberately introduced faults.  */
344   if (!err && !opt.no_sig_create_check)
345     {
346       PKT_public_key *pk = xmalloc_clear (sizeof *pk);
347
348       if (get_pubkey (pk, sig->keyid ))
349         err = gpg_error (GPG_ERR_NO_PUBKEY);
350       else 
351         {
352           frame = encode_md_value (pk, md, sig->digest_algo );
353           if (!frame)
354             err = gpg_error (GPG_ERR_GENERAL);
355           else
356             err = pk_verify (pk->pubkey_algo, frame, sig->data, pk->pkey);
357           gcry_mpi_release (frame);
358         }
359       if (err)
360         log_error (_("checking created signature failed: %s\n"),
361                    g10_errstr (err));
362       free_public_key (pk);
363     }
364
365   if (err)
366     log_error (_("signing failed: %s\n"), g10_errstr (err));
367   else 
368     {
369       if (opt.verbose)
370         {
371           char *ustr = get_user_id_string_native (sig->keyid);
372           log_info (_("%s/%s signature from: \"%s\"\n"),
373                     gcry_pk_algo_name (pksk->pubkey_algo),
374                     gcry_md_algo_name (sig->digest_algo),
375                     ustr);
376           xfree (ustr);
377         }
378     }
379   return err;
380 }
381
382
383 int
384 complete_sig (PKT_signature *sig, PKT_public_key *pksk, gcry_md_hd_t md)
385 {
386   int rc;
387
388   /* if (!(rc = check_secret_key (pksk, 0))) */
389     rc = do_sign (pksk, sig, md, 0);
390   return rc;
391 }
392
393
394
395 static int
396 match_dsa_hash (unsigned int qbytes)
397 {
398   if (qbytes <= 20)
399     return DIGEST_ALGO_SHA1;
400
401   if (qbytes <= 28)
402     return DIGEST_ALGO_SHA224;
403
404   if (qbytes <= 32)
405     return DIGEST_ALGO_SHA256;
406
407   if (qbytes <= 48)
408     return DIGEST_ALGO_SHA384;
409
410   if (qbytes <= 64)
411     return DIGEST_ALGO_SHA512;
412
413   return DEFAULT_DIGEST_ALGO;
414   /* DEFAULT_DIGEST_ALGO will certainly fail, but it's the best wrong
415      answer we have if a digest larger than 512 bits is requested.  */
416 }
417
418
419 /*
420   First try --digest-algo.  If that isn't set, see if the recipient
421   has a preferred algorithm (which is also filtered through
422   --preferred-digest-prefs).  If we're making a signature without a
423   particular recipient (i.e. signing, rather than signing+encrypting)
424   then take the first algorithm in --preferred-digest-prefs that is
425   usable for the pubkey algorithm.  If --preferred-digest-prefs isn't
426   set, then take the OpenPGP default (i.e. SHA-1).
427
428   Possible improvement: Use the highest-ranked usable algorithm from
429   the signing key prefs either before or after using the personal
430   list?
431 */
432 static int
433 hash_for (PKT_public_key *pk)
434 {
435   if (opt.def_digest_algo)
436     {
437       return opt.def_digest_algo;
438     }
439   else if (recipient_digest_algo)
440     {
441       return recipient_digest_algo;
442     }
443   else if (pk->pubkey_algo == PUBKEY_ALGO_DSA)
444     {
445       unsigned int qbytes = gcry_mpi_get_nbits (pk->pkey[1]) / 8;
446
447       /* It's a DSA key, so find a hash that is the same size as q or
448          larger.  If q is 160, assume it is an old DSA key and use a
449          160-bit hash unless --enable-dsa2 is set, in which case act
450          like a new DSA key that just happens to have a 160-bit q
451          (i.e. allow truncation).  If q is not 160, by definition it
452          must be a new DSA key. */
453
454       if (opt.personal_digest_prefs)
455         {
456           prefitem_t *prefs;
457
458           if (qbytes != 20 || opt.flags.dsa2)
459             {
460               for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
461                 if (gcry_md_get_algo_dlen (prefs->value) >= qbytes)
462                   return prefs->value;
463             }
464           else
465             {
466               for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
467                 if (gcry_md_get_algo_dlen (prefs->value) == qbytes)
468                   return prefs->value;
469             }
470         }
471
472       return match_dsa_hash(qbytes);
473     }
474   else if (0 
475            /* FIXME: call agent sk->is_protected && sk->protect.s2k.mode == 1002
476            && sk->protect.ivlen == 16
477            && !memcmp (sk->protect.iv, "\xD2\x76\x00\x01\x24\x01\x01", 7)*/)
478     {
479       /* The sk lives on a smartcard, and old smartcards only handle
480          SHA-1 and RIPEMD/160.  Newer smartcards (v2.0) don't have
481          this restriction anymore.  Fortunately the serial number
482          encodes the version of the card and thus we know that this
483          key is on a v1 card. */
484       if(opt.personal_digest_prefs)
485         {
486           prefitem_t *prefs;
487
488           for (prefs=opt.personal_digest_prefs;prefs->type;prefs++)
489             if (prefs->value==DIGEST_ALGO_SHA1
490                 || prefs->value==DIGEST_ALGO_RMD160)
491               return prefs->value;
492         }
493
494       return DIGEST_ALGO_SHA1;
495     }
496   else if (PGP2 && pk->pubkey_algo == PUBKEY_ALGO_RSA && pk->version < 4 )
497     {
498       /* Old-style PGP only understands MD5 */
499       return DIGEST_ALGO_MD5;
500     }
501   else if (opt.personal_digest_prefs)
502     {
503       /* It's not DSA, so we can use whatever the first hash algorithm
504          is in the pref list */
505       return opt.personal_digest_prefs[0].value;
506     }
507   else
508     return DEFAULT_DIGEST_ALGO;
509 }
510
511
512 /* Return true iff all keys in SK_LIST are old style (v3 RSA).  */
513 static int
514 only_old_style (SK_LIST sk_list)
515 {
516   SK_LIST sk_rover = NULL;
517   int old_style = 0;
518   
519   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
520     {
521       PKT_public_key *pk = sk_rover->pk;
522
523       if (pk->pubkey_algo == PUBKEY_ALGO_RSA && pk->version < 4)
524         old_style = 1;
525       else
526         return 0;
527     }
528   return old_style;
529 }
530
531
532 static void
533 print_status_sig_created (PKT_public_key *pk, PKT_signature *sig, int what)
534 {
535   byte array[MAX_FINGERPRINT_LEN];
536   char buf[100+MAX_FINGERPRINT_LEN*2];
537   size_t n;
538   
539   snprintf (buf, sizeof buf - 2*MAX_FINGERPRINT_LEN, "%c %d %d %02x %lu ",
540             what, sig->pubkey_algo, sig->digest_algo, sig->sig_class,
541             (ulong)sig->timestamp );
542   fingerprint_from_pk (pk, array, &n);
543   bin2hex (array, n, buf + strlen (buf));
544   
545   write_status_text( STATUS_SIG_CREATED, buf );
546 }
547
548
549 /*
550  * Loop over the secret certificates in SK_LIST and build the one pass
551  * signature packets.  OpenPGP says that the data should be bracket by
552  * the onepass-sig and signature-packet; so we build these onepass
553  * packet here in reverse order 
554  */
555 static int
556 write_onepass_sig_packets (SK_LIST sk_list, IOBUF out, int sigclass )
557 {
558     int skcount;
559     SK_LIST sk_rover;
560
561     for (skcount=0, sk_rover=sk_list; sk_rover; sk_rover = sk_rover->next)
562         skcount++;
563
564     for (; skcount; skcount--) {
565         PKT_public_key *pk;
566         PKT_onepass_sig *ops;
567         PACKET pkt;
568         int i, rc;
569         
570         for (i=0, sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
571             if (++i == skcount)
572                 break;
573         }
574
575         pk = sk_rover->pk;
576         ops = xmalloc_clear (sizeof *ops);
577         ops->sig_class = sigclass;
578         ops->digest_algo = hash_for (pk);
579         ops->pubkey_algo = pk->pubkey_algo;
580         keyid_from_pk (pk, ops->keyid);
581         ops->last = (skcount == 1);
582         
583         init_packet(&pkt);
584         pkt.pkttype = PKT_ONEPASS_SIG;
585         pkt.pkt.onepass_sig = ops;
586         rc = build_packet (out, &pkt);
587         free_packet (&pkt);
588         if (rc) {
589             log_error ("build onepass_sig packet failed: %s\n",
590                        g10_errstr(rc));
591             return rc;
592         }
593     }
594
595     return 0;
596 }
597
598 /*
599  * Helper to write the plaintext (literal data) packet
600  */
601 static int
602 write_plaintext_packet (IOBUF out, IOBUF inp, const char *fname, int ptmode)
603 {
604     PKT_plaintext *pt = NULL;
605     u32 filesize;
606     int rc = 0;
607
608     if (!opt.no_literal)
609       pt=setup_plaintext_name(fname,inp);
610
611     /* try to calculate the length of the data */
612     if ( !iobuf_is_pipe_filename (fname) && *fname )
613       {
614         off_t tmpsize;
615         int overflow;
616
617         if( !(tmpsize = iobuf_get_filelength(inp, &overflow))
618             && !overflow && opt.verbose)
619           log_info (_("WARNING: `%s' is an empty file\n"), fname);
620
621         /* We can't encode the length of very large files because
622            OpenPGP uses only 32 bit for file sizes.  So if the size of
623            a file is larger than 2^32 minus some bytes for packet
624            headers, we switch to partial length encoding. */
625         if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
626           filesize = tmpsize;
627         else
628           filesize = 0;
629
630         /* Because the text_filter modifies the length of the
631          * data, it is not possible to know the used length
632          * without a double read of the file - to avoid that
633          * we simple use partial length packets. */
634         if ( ptmode == 't' )
635           filesize = 0;
636       }
637     else
638       filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
639
640     if (!opt.no_literal) {
641         PACKET pkt;
642
643         pt->timestamp = make_timestamp ();
644         pt->mode = ptmode;
645         pt->len = filesize;
646         pt->new_ctb = !pt->len && !RFC1991;
647         pt->buf = inp;
648         init_packet(&pkt);
649         pkt.pkttype = PKT_PLAINTEXT;
650         pkt.pkt.plaintext = pt;
651         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
652         if( (rc = build_packet (out, &pkt)) )
653             log_error ("build_packet(PLAINTEXT) failed: %s\n",
654                        g10_errstr(rc) );
655         pt->buf = NULL;
656     }
657     else {
658         byte copy_buffer[4096];
659         int  bytes_copied;
660
661         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
662             if ( (rc=iobuf_write(out, copy_buffer, bytes_copied)) ) {
663                 log_error ("copying input to output failed: %s\n",
664                            gpg_strerror (rc));
665                 break;
666             }
667         wipememory(copy_buffer,4096); /* burn buffer */
668     }
669     /* fixme: it seems that we never freed pt/pkt */
670     
671     return rc;
672 }
673
674 /*
675  * Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
676  * hash which will not be changes here.
677  */
678 static int
679 write_signature_packets (SK_LIST sk_list, IOBUF out, gcry_md_hd_t hash,
680                          int sigclass, u32 timestamp, u32 duration,
681                          int status_letter)
682 {
683   SK_LIST sk_rover;
684   
685   /* Loop over the certificates with secret keys. */
686   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
687     {
688       PKT_public_key *pk;
689       PKT_signature *sig;
690       gcry_md_hd_t md;
691       int rc;
692
693       pk = sk_rover->pk;
694
695       /* Build the signature packet.  */
696       sig = xmalloc_clear (sizeof *sig);
697       if (opt.force_v3_sigs || RFC1991)
698         sig->version = 3;
699       else if (duration || opt.sig_policy_url
700                || opt.sig_notations || opt.sig_keyserver_url)
701         sig->version = 4;
702       else
703         sig->version = pk->version;
704
705       keyid_from_pk (pk, sig->keyid);
706       sig->digest_algo = hash_for (pk);
707       sig->pubkey_algo = pk->pubkey_algo;
708       if (timestamp)
709         sig->timestamp = timestamp;
710       else
711         sig->timestamp = make_timestamp();
712       if (duration)
713         sig->expiredate = sig->timestamp + duration;
714       sig->sig_class = sigclass;
715
716       if (gcry_md_copy (&md, hash))
717         BUG ();
718       
719       if (sig->version >= 4)
720         {
721           build_sig_subpkt_from_sig (sig);
722           mk_notation_policy_etc (sig, pk, NULL);
723         }
724       
725       hash_sigversion_to_magic (md, sig);
726       gcry_md_final (md);
727
728       rc = do_sign (pk, sig, md, hash_for (pk));
729       gcry_md_close (md);
730       if (!rc)
731         { 
732           /* Write the packet.  */
733           PACKET pkt;
734           
735           init_packet (&pkt);
736           pkt.pkttype = PKT_SIGNATURE;
737           pkt.pkt.signature = sig;
738           rc = build_packet (out, &pkt);
739           if (!rc && is_status_enabled())
740             print_status_sig_created (pk, sig, status_letter);
741           free_packet (&pkt);
742           if (rc)
743             log_error ("build signature packet failed: %s\n", gpg_strerror (rc));
744         }
745       if (rc)
746         return rc;
747     }
748   
749   return 0;
750 }
751
752
753 /****************
754  * Sign the files whose names are in FILENAME.
755  * If DETACHED has the value true,
756  * make a detached signature.  If FILENAMES->d is NULL read from stdin
757  * and ignore the detached mode.  Sign the file with all secret keys
758  * which can be taken from LOCUSR, if this is NULL, use the default one
759  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
760  * signed data for these users.
761  * If OUTFILE is not NULL; this file is used for output and the function
762  * does not ask for overwrite permission; output is then always
763  * uncompressed, non-armored and in binary mode.
764  */
765 int
766 sign_file( strlist_t filenames, int detached, strlist_t locusr,
767            int encryptflag, strlist_t remusr, const char *outfile )
768 {
769     const char *fname;
770     armor_filter_context_t *afx;
771     compress_filter_context_t zfx;
772     md_filter_context_t mfx;
773     text_filter_context_t tfx;
774     progress_filter_context_t *pfx;
775     encrypt_filter_context_t efx;
776     IOBUF inp = NULL, out = NULL;
777     PACKET pkt;
778     int rc = 0;
779     PK_LIST pk_list = NULL;
780     SK_LIST sk_list = NULL;
781     SK_LIST sk_rover = NULL;
782     int multifile = 0;
783     u32 duration=0;
784
785     pfx = new_progress_context ();
786     afx = new_armor_context ();
787     memset( &zfx, 0, sizeof zfx);
788     memset( &mfx, 0, sizeof mfx);
789     memset( &efx, 0, sizeof efx);
790     init_packet( &pkt );
791
792     if( filenames ) {
793         fname = filenames->d;
794         multifile = !!filenames->next;
795     }
796     else
797         fname = NULL;
798
799     if( fname && filenames->next && (!detached || encryptflag) )
800         log_bug("multiple files can only be detached signed");
801
802     if(encryptflag==2
803        && (rc=setup_symkey(&efx.symkey_s2k,&efx.symkey_dek)))
804       goto leave;
805
806     if(!opt.force_v3_sigs && !RFC1991)
807       {
808         if(opt.ask_sig_expire && !opt.batch)
809           duration=ask_expire_interval(1,opt.def_sig_expire);
810         else
811           duration=parse_expire_string(opt.def_sig_expire);
812       }
813
814     /* Note: In the old non-agent version the following call used to
815        unprotect the secret key.  This is now done on demand by the agent.  */
816     if( (rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG )) )
817         goto leave;
818
819     if(PGP2 && !only_old_style(sk_list))
820       {
821         log_info(_("you can only detach-sign with PGP 2.x style keys "
822                    "while in --pgp2 mode\n"));
823         compliance_failure();
824       }
825
826     if(encryptflag && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
827       goto leave;
828
829     /* prepare iobufs */
830     if( multifile )  /* have list of filenames */
831         inp = NULL; /* we do it later */
832     else {
833       inp = iobuf_open(fname);
834       if (inp && is_secured_file (iobuf_get_fd (inp)))
835         {
836           iobuf_close (inp);
837           inp = NULL;
838           gpg_err_set_errno (EPERM);
839         }
840       if( !inp ) 
841         {
842           rc = gpg_error_from_syserror ();
843           log_error (_("can't open `%s': %s\n"), fname? fname: "[stdin]",
844                      strerror(errno) );
845           goto leave;
846         }
847
848         handle_progress (pfx, inp, fname);
849     }
850
851     if( outfile ) {
852         if (is_secured_filename ( outfile )) {
853             out = NULL;
854             gpg_err_set_errno (EPERM);
855         }
856         else
857             out = iobuf_create( outfile );
858         if( !out )
859           {
860             rc = gpg_error_from_syserror ();
861             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
862             goto leave;
863           }
864         else if( opt.verbose )
865             log_info(_("writing to `%s'\n"), outfile );
866     }
867     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname,
868                                  opt.armor? 1: detached? 2:0, &out )))
869         goto leave;
870
871     /* prepare to calculate the MD over the input */
872     if( opt.textmode && !outfile && !multifile )
873       {
874         memset( &tfx, 0, sizeof tfx);
875         iobuf_push_filter( inp, text_filter, &tfx );
876       }
877
878     if ( gcry_md_open (&mfx.md, 0, 0) )
879       BUG ();
880     if (DBG_HASHING)
881       gcry_md_start_debug (mfx.md, "sign");
882
883     /* If we're encrypting and signing, it is reasonable to pick the
884        hash algorithm to use out of the recepient key prefs.  This is
885        best effort only, as in a DSA2 and smartcard world there are
886        cases where we cannot please everyone with a single hash (DSA2
887        wants >160 and smartcards want =160).  In the future this could
888        be more complex with different hashes for each sk, but the
889        current design requires a single hash for all SKs. */
890     if(pk_list)
891       {
892         if(opt.def_digest_algo)
893           {
894             if(!opt.expert &&
895                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
896                                       opt.def_digest_algo,
897                                       NULL)!=opt.def_digest_algo)
898           log_info(_("WARNING: forcing digest algorithm %s (%d)"
899                      " violates recipient preferences\n"),
900                    gcry_md_algo_name (opt.def_digest_algo),
901                    opt.def_digest_algo );
902           }
903         else
904           {
905             int algo, smartcard=0;
906             union pref_hint hint;
907
908             hint.digest_length = 0;
909
910             /* Of course, if the recipient asks for something
911                unreasonable (like the wrong hash for a DSA key) then
912                don't do it.  Check all sk's - if any are DSA or live
913                on a smartcard, then the hash has restrictions and we
914                may not be able to give the recipient what they want.
915                For DSA, pass a hint for the largest q we have.  Note
916                that this means that a q>160 key will override a q=160
917                key and force the use of truncation for the q=160 key.
918                The alternative would be to ignore the recipient prefs
919                completely and get a different hash for each DSA key in
920                hash_for().  The override behavior here is more or less
921                reasonable as it is under the control of the user which
922                keys they sign with for a given message and the fact
923                that the message with multiple signatures won't be
924                usable on an implementation that doesn't understand
925                DSA2 anyway. */
926
927             for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
928               {
929                 if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_DSA)
930                   {
931                     int temp_hashlen = gcry_mpi_get_nbits
932                       (sk_rover->pk->pkey[1])+7/8;
933
934                     /* Pick a hash that is large enough for our
935                        largest q */
936
937                     if (hint.digest_length<temp_hashlen)
938                       hint.digest_length=temp_hashlen;
939                   }
940                 /* FIXME: need toall gpg-agent */
941                 /* else if (sk_rover->pk->is_protected */
942                 /*          && sk_rover->pk->protect.s2k.mode == 1002) */
943                 /*   smartcard = 1;  */
944               }
945
946             /* Current smartcards only do 160-bit hashes.  If we have
947                to have a >160-bit hash, then we can't use the
948                recipient prefs as we'd need both =160 and >160 at the
949                same time and recipient prefs currently require a
950                single hash for all signatures.  All this may well have
951                to change as the cards add algorithms. */
952
953             if (!smartcard || (smartcard && hint.digest_length==20))
954               if ( (algo=
955                    select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint)) > 0)
956                 recipient_digest_algo=algo;
957           }
958       }
959
960     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
961       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
962
963     if( !multifile )
964         iobuf_push_filter( inp, md_filter, &mfx );
965
966     if( detached && !encryptflag && !RFC1991 )
967         afx->what = 2;
968
969     if( opt.armor && !outfile  )
970         push_armor_filter (afx, out);
971
972     if( encryptflag ) {
973         efx.pk_list = pk_list;
974         /* fixme: set efx.cfx.datalen if known */
975         iobuf_push_filter( out, encrypt_filter, &efx );
976     }
977
978     if( opt.compress_algo && !outfile && ( !detached || opt.compress_sigs) )
979       {
980         int compr_algo=opt.compress_algo;
981
982         /* If not forced by user */
983         if(compr_algo==-1)
984           {
985             /* If we're not encrypting, then select_algo_from_prefs
986                will fail and we'll end up with the default.  If we are
987                encrypting, select_algo_from_prefs cannot fail since
988                there is an assumed preference for uncompressed data.
989                Still, if it did fail, we'll also end up with the
990                default. */
991  
992             if((compr_algo=
993                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
994               compr_algo=default_compress_algo();
995           }
996         else if(!opt.expert && pk_list
997                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
998                                           compr_algo,NULL)!=compr_algo)
999           log_info(_("WARNING: forcing compression algorithm %s (%d)"
1000                      " violates recipient preferences\n"),
1001                    compress_algo_to_string(compr_algo),compr_algo);
1002
1003         /* algo 0 means no compression */
1004         if( compr_algo )
1005           push_compress_filter(out,&zfx,compr_algo);
1006       }
1007
1008     /* Write the one-pass signature packets if needed */
1009     if (!detached && !RFC1991) {
1010         rc = write_onepass_sig_packets (sk_list, out,
1011                                         opt.textmode && !outfile ? 0x01:0x00);
1012         if (rc)
1013             goto leave;
1014     }
1015
1016     write_status_begin_signing (mfx.md);
1017
1018     /* Setup the inner packet. */
1019     if( detached ) {
1020         if( multifile ) {
1021             strlist_t sl;
1022
1023             if( opt.verbose )
1024                 log_info(_("signing:") );
1025             /* must walk reverse trough this list */
1026             for( sl = strlist_last(filenames); sl;
1027                         sl = strlist_prev( filenames, sl ) ) {
1028                 inp = iobuf_open(sl->d);
1029                 if (inp && is_secured_file (iobuf_get_fd (inp)))
1030                   {
1031                     iobuf_close (inp);
1032                     inp = NULL;
1033                     gpg_err_set_errno (EPERM);
1034                   }
1035                 if( !inp )
1036                   {
1037                     rc = gpg_error_from_syserror ();
1038                     log_error(_("can't open `%s': %s\n"),
1039                               sl->d,strerror(errno));
1040                     goto leave;
1041                   }
1042                 handle_progress (pfx, inp, sl->d);
1043                 if( opt.verbose )
1044                     fprintf(stderr, " `%s'", sl->d );
1045                 if(opt.textmode)
1046                   {
1047                     memset( &tfx, 0, sizeof tfx);
1048                     iobuf_push_filter( inp, text_filter, &tfx );
1049                   }
1050                 iobuf_push_filter( inp, md_filter, &mfx );
1051                 while( iobuf_get(inp) != -1 )
1052                     ;
1053                 iobuf_close(inp); inp = NULL;
1054             }
1055             if( opt.verbose )
1056                 putc( '\n', stderr );
1057         }
1058         else {
1059             /* read, so that the filter can calculate the digest */
1060             while( iobuf_get(inp) != -1 )
1061                 ;
1062         }
1063     }
1064     else {
1065         rc = write_plaintext_packet (out, inp, fname,
1066                                      opt.textmode && !outfile ? 't':'b');
1067     }
1068
1069     /* catch errors from above */
1070     if (rc)
1071         goto leave;
1072
1073     /* write the signatures */
1074     rc = write_signature_packets (sk_list, out, mfx.md,
1075                                   opt.textmode && !outfile? 0x01 : 0x00,
1076                                   0, duration, detached ? 'D':'S');
1077     if( rc )
1078         goto leave;
1079
1080
1081   leave:
1082     if( rc )
1083         iobuf_cancel(out);
1084     else {
1085         iobuf_close(out);
1086         if (encryptflag)
1087             write_status( STATUS_END_ENCRYPTION );
1088     }
1089     iobuf_close(inp);
1090     gcry_md_close ( mfx.md );
1091     release_sk_list( sk_list );
1092     release_pk_list( pk_list );
1093     recipient_digest_algo=0;
1094     release_progress_context (pfx);
1095     release_armor_context (afx);
1096     return rc;
1097 }
1098
1099
1100
1101 /****************
1102  * make a clear signature. note that opt.armor is not needed
1103  */
1104 int
1105 clearsign_file( const char *fname, strlist_t locusr, const char *outfile )
1106 {
1107     armor_filter_context_t *afx;
1108     progress_filter_context_t *pfx;
1109     gcry_md_hd_t textmd = NULL;
1110     IOBUF inp = NULL, out = NULL;
1111     PACKET pkt;
1112     int rc = 0;
1113     SK_LIST sk_list = NULL;
1114     SK_LIST sk_rover = NULL;
1115     int old_style = RFC1991;
1116     int only_md5 = 0;
1117     u32 duration=0;
1118
1119     pfx = new_progress_context ();
1120     afx = new_armor_context ();
1121     init_packet( &pkt );
1122
1123     if(!opt.force_v3_sigs && !RFC1991)
1124       {
1125         if(opt.ask_sig_expire && !opt.batch)
1126           duration=ask_expire_interval(1,opt.def_sig_expire);
1127         else
1128           duration=parse_expire_string(opt.def_sig_expire);
1129       }
1130
1131     /* Note: In the old non-agent version the following call used to
1132        unprotect the secret key.  This is now done on demand by the agent.  */
1133     if( (rc=build_sk_list( locusr, &sk_list, PUBKEY_USAGE_SIG )) )
1134         goto leave;
1135
1136     if( !old_style && !duration )
1137         old_style = only_old_style( sk_list );
1138
1139     if(PGP2 && !only_old_style(sk_list))
1140       {
1141         log_info(_("you can only clearsign with PGP 2.x style keys "
1142                    "while in --pgp2 mode\n"));
1143         compliance_failure();
1144       }
1145
1146     /* prepare iobufs */
1147     inp = iobuf_open(fname);
1148     if (inp && is_secured_file (iobuf_get_fd (inp)))
1149       {
1150         iobuf_close (inp);
1151         inp = NULL;
1152         gpg_err_set_errno (EPERM);
1153       }
1154     if( !inp ) {
1155         rc = gpg_error_from_syserror ();
1156         log_error (_("can't open `%s': %s\n"), 
1157                    fname? fname: "[stdin]", strerror(errno) );
1158         goto leave;
1159     }
1160     handle_progress (pfx, inp, fname);
1161
1162     if( outfile ) {
1163         if (is_secured_filename (outfile) ) {
1164             outfile = NULL;
1165             gpg_err_set_errno (EPERM);
1166         }
1167         else 
1168             out = iobuf_create( outfile );
1169         if( !out )
1170           {
1171             rc = gpg_error_from_syserror ();
1172             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
1173             goto leave;
1174           }
1175         else if( opt.verbose )
1176             log_info(_("writing to `%s'\n"), outfile );
1177     }
1178     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname, 1, &out )) )
1179         goto leave;
1180
1181     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1182
1183     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1184       {
1185         if (hash_for (sk_rover->pk) == DIGEST_ALGO_MD5)
1186           only_md5 = 1;
1187         else 
1188           {
1189             only_md5 = 0;
1190             break;
1191           }
1192       }
1193
1194     if( !(old_style && only_md5) ) {
1195         const char *s;
1196         int any = 0;
1197         byte hashs_seen[256];
1198
1199         memset( hashs_seen, 0, sizeof hashs_seen );
1200         iobuf_writestr(out, "Hash: " );
1201         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1202             int i = hash_for (sk_rover->pk);
1203
1204             if( !hashs_seen[ i & 0xff ] ) {
1205                 s = gcry_md_algo_name ( i );
1206                 if( s ) {
1207                     hashs_seen[ i & 0xff ] = 1;
1208                     if( any )
1209                         iobuf_put(out, ',' );
1210                     iobuf_writestr(out, s );
1211                     any = 1;
1212                 }
1213             }
1214         }
1215         assert(any);
1216         iobuf_writestr(out, LF );
1217     }
1218
1219     if( opt.not_dash_escaped )
1220       iobuf_writestr( out,
1221                   "NotDashEscaped: You need GnuPG to verify this message" LF );
1222     iobuf_writestr(out, LF );
1223
1224     if ( gcry_md_open (&textmd, 0, 0) )
1225       BUG ();
1226     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1227       gcry_md_enable (textmd, hash_for(sk_rover->pk));
1228
1229     if ( DBG_HASHING )
1230       gcry_md_start_debug ( textmd, "clearsign" );
1231
1232     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
1233                         opt.escape_from, (old_style && only_md5) );
1234     /* fixme: check for read errors */
1235
1236     /* now write the armor */
1237     afx->what = 2;
1238     push_armor_filter (afx, out);
1239
1240     /* write the signatures */
1241     rc=write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C');
1242     if( rc )
1243         goto leave;
1244
1245   leave:
1246     if( rc )
1247         iobuf_cancel(out);
1248     else
1249         iobuf_close(out);
1250     iobuf_close(inp);
1251     gcry_md_close ( textmd );
1252     release_sk_list( sk_list );
1253     release_progress_context (pfx);
1254     release_armor_context (afx); 
1255     return rc;
1256 }
1257
1258 /*
1259  * Sign and conventionally encrypt the given file.
1260  * FIXME: Far too much code is duplicated - revamp the whole file.
1261  */
1262 int
1263 sign_symencrypt_file (const char *fname, strlist_t locusr)
1264 {
1265     armor_filter_context_t *afx;
1266     progress_filter_context_t *pfx;
1267     compress_filter_context_t zfx;
1268     md_filter_context_t mfx;
1269     text_filter_context_t tfx;
1270     cipher_filter_context_t cfx;
1271     IOBUF inp = NULL, out = NULL;
1272     PACKET pkt;
1273     STRING2KEY *s2k = NULL;
1274     int rc = 0;
1275     SK_LIST sk_list = NULL;
1276     SK_LIST sk_rover = NULL;
1277     int algo;
1278     u32 duration=0;
1279     int canceled;
1280
1281     pfx = new_progress_context ();
1282     afx = new_armor_context ();
1283     memset( &zfx, 0, sizeof zfx);
1284     memset( &mfx, 0, sizeof mfx);
1285     memset( &tfx, 0, sizeof tfx);
1286     memset( &cfx, 0, sizeof cfx);
1287     init_packet( &pkt );
1288
1289     if(!opt.force_v3_sigs && !RFC1991)
1290       {
1291         if(opt.ask_sig_expire && !opt.batch)
1292           duration=ask_expire_interval(1,opt.def_sig_expire);
1293         else
1294           duration=parse_expire_string(opt.def_sig_expire);
1295       }
1296
1297     /* Note: In the old non-agent version the following call used to
1298        unprotect the secret key.  This is now done on demand by the agent.  */
1299     rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG);
1300     if (rc) 
1301         goto leave;
1302
1303     /* prepare iobufs */
1304     inp = iobuf_open(fname);
1305     if (inp && is_secured_file (iobuf_get_fd (inp)))
1306       {
1307         iobuf_close (inp);
1308         inp = NULL;
1309         gpg_err_set_errno (EPERM);
1310       }
1311     if( !inp ) {
1312         rc = gpg_error_from_syserror ();
1313         log_error (_("can't open `%s': %s\n"), 
1314                    fname? fname: "[stdin]", strerror(errno) );
1315         goto leave;
1316     }
1317     handle_progress (pfx, inp, fname);
1318
1319     /* prepare key */
1320     s2k = xmalloc_clear( sizeof *s2k );
1321     s2k->mode = RFC1991? 0:opt.s2k_mode;
1322     s2k->hash_algo = S2K_DIGEST_ALGO;
1323
1324     algo = default_cipher_algo();
1325     if (!opt.quiet || !opt.batch)
1326         log_info (_("%s encryption will be used\n"),
1327                   openpgp_cipher_algo_name (algo) );
1328     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, &canceled);
1329
1330     if (!cfx.dek || !cfx.dek->keylen) {
1331         rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
1332         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1333         goto leave;
1334     }
1335
1336     /* We have no way to tell if the recipient can handle messages
1337        with an MDC, so this defaults to no.  Perhaps in a few years,
1338        this can be defaulted to yes.  Note that like regular
1339        encrypting, --force-mdc overrides --disable-mdc. */
1340     if(opt.force_mdc)
1341       cfx.dek->use_mdc=1;
1342
1343     /* now create the outfile */
1344     rc = open_outfile (GNUPG_INVALID_FD, fname, opt.armor? 1:0, &out);
1345     if (rc)
1346         goto leave;
1347
1348     /* prepare to calculate the MD over the input */
1349     if (opt.textmode)
1350         iobuf_push_filter (inp, text_filter, &tfx);
1351     if ( gcry_md_open (&mfx.md, 0, 0) )
1352       BUG ();
1353     if ( DBG_HASHING )
1354       gcry_md_start_debug (mfx.md, "symc-sign");
1355
1356     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1357       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
1358
1359     iobuf_push_filter (inp, md_filter, &mfx);
1360
1361     /* Push armor output filter */
1362     if (opt.armor)
1363         push_armor_filter (afx, out);
1364
1365     /* Write the symmetric key packet */
1366     /*(current filters: armor)*/
1367     if (!RFC1991) {
1368         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1369         enc->version = 4;
1370         enc->cipher_algo = cfx.dek->algo;
1371         enc->s2k = *s2k;
1372         pkt.pkttype = PKT_SYMKEY_ENC;
1373         pkt.pkt.symkey_enc = enc;
1374         if( (rc = build_packet( out, &pkt )) )
1375             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1376         xfree(enc);
1377     }
1378
1379     /* Push the encryption filter */
1380     iobuf_push_filter( out, cipher_filter, &cfx );
1381
1382     /* Push the compress filter */
1383     if (default_compress_algo())
1384       push_compress_filter(out,&zfx,default_compress_algo());
1385
1386     /* Write the one-pass signature packets */
1387     /*(current filters: zip - encrypt - armor)*/
1388     if (!RFC1991) {
1389         rc = write_onepass_sig_packets (sk_list, out,
1390                                         opt.textmode? 0x01:0x00);
1391         if (rc)
1392             goto leave;
1393     }
1394
1395     write_status_begin_signing (mfx.md);
1396
1397     /* Pipe data through all filters; i.e. write the signed stuff */
1398     /*(current filters: zip - encrypt - armor)*/
1399     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1400     if (rc)
1401         goto leave;
1402     
1403     /* Write the signatures */
1404     /*(current filters: zip - encrypt - armor)*/
1405     rc = write_signature_packets (sk_list, out, mfx.md,
1406                                   opt.textmode? 0x01 : 0x00,
1407                                   0, duration, 'S');
1408     if( rc )
1409         goto leave;
1410
1411
1412   leave:
1413     if( rc )
1414         iobuf_cancel(out);
1415     else {
1416         iobuf_close(out);
1417         write_status( STATUS_END_ENCRYPTION );
1418     }
1419     iobuf_close(inp);
1420     release_sk_list( sk_list );
1421     gcry_md_close( mfx.md );
1422     xfree(cfx.dek);
1423     xfree(s2k);
1424     release_progress_context (pfx);
1425     release_armor_context (afx);
1426     return rc;
1427 }
1428
1429
1430 /****************
1431  * Create a signature packet for the given public key certificate and
1432  * the user id and return it in ret_sig. User signature class SIGCLASS
1433  * user-id is not used (and may be NULL if sigclass is 0x20) If
1434  * DIGEST_ALGO is 0 the function selects an appropriate one.
1435  * SIGVERSION gives the minimal required signature packet version;
1436  * this is needed so that special properties like local sign are not
1437  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1438  * the timestamp to use for the signature. 0 means "now" */
1439 int
1440 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1441                     PKT_user_id *uid, PKT_public_key *subpk,
1442                     PKT_public_key *pksk,
1443                     int sigclass, int digest_algo,
1444                     int sigversion, u32 timestamp, u32 duration,
1445                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
1446                    )
1447 {
1448     PKT_signature *sig;
1449     int rc=0;
1450     gcry_md_hd_t md;
1451
1452     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1453             || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1454             || sigclass == 0x30 || sigclass == 0x28 );
1455
1456     if (opt.force_v4_certs)
1457         sigversion = 4;
1458
1459     if (sigversion < pksk->version)
1460         sigversion = pksk->version;
1461
1462     /* If you are making a signature on a v4 key using your v3 key, it
1463        doesn't make sense to generate a v3 sig.  After all, no v3-only
1464        PGP implementation could understand the v4 key in the first
1465        place.  Note that this implies that a signature on an attribute
1466        uid is usually going to be v4 as well, since they are not
1467        generally found on v3 keys. */
1468     if (sigversion < pk->version)
1469         sigversion = pk->version;
1470
1471     if( !digest_algo )
1472       {
1473         /* Basically, this means use SHA1 always unless it's a v3 RSA
1474            key making a v3 cert (use MD5), or the user specified
1475            something (use whatever they said), or it's DSA (use the
1476            best match).  They still can't pick an inappropriate hash
1477            for DSA or the signature will fail.  Note that this still
1478            allows the caller of make_keysig_packet to override the
1479            user setting if it must. */
1480
1481         if(opt.cert_digest_algo)
1482           digest_algo=opt.cert_digest_algo;
1483         else if(pksk->pubkey_algo==PUBKEY_ALGO_RSA
1484                 && pk->version<4 && sigversion<4)
1485           digest_algo = DIGEST_ALGO_MD5;
1486         else if(pksk->pubkey_algo==PUBKEY_ALGO_DSA)
1487           digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
1488         else
1489           digest_algo = DIGEST_ALGO_SHA1;
1490       }
1491
1492     if ( gcry_md_open (&md, digest_algo, 0 ) )
1493       BUG ();
1494
1495     /* Hash the public key certificate. */
1496     hash_public_key( md, pk );
1497
1498     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1499       {
1500         /* hash the subkey binding/backsig/revocation */
1501         hash_public_key( md, subpk );
1502       }
1503     else if( sigclass != 0x1F && sigclass != 0x20 )
1504       {
1505         /* hash the user id */
1506         hash_uid (md, sigversion, uid);
1507       }
1508     /* and make the signature packet */
1509     sig = xmalloc_clear( sizeof *sig );
1510     sig->version = sigversion;
1511     sig->flags.exportable=1;
1512     sig->flags.revocable=1;
1513     keyid_from_pk (pksk, sig->keyid);
1514     sig->pubkey_algo = pksk->pubkey_algo;
1515     sig->digest_algo = digest_algo;
1516     if(timestamp)
1517       sig->timestamp=timestamp;
1518     else
1519       sig->timestamp=make_timestamp();
1520     if(duration)
1521       sig->expiredate=sig->timestamp+duration;
1522     sig->sig_class = sigclass;
1523     if( sig->version >= 4 )
1524       {
1525         build_sig_subpkt_from_sig( sig );
1526         mk_notation_policy_etc (sig, pk, pksk);
1527       }
1528
1529     /* Crucial that the call to mksubpkt comes LAST before the calls
1530        to finalize the sig as that makes it possible for the mksubpkt
1531        function to get a reliable pointer to the subpacket area. */
1532     if( sig->version >= 4 && mksubpkt )
1533         rc = (*mksubpkt)( sig, opaque );
1534
1535     if( !rc ) {
1536         hash_sigversion_to_magic (md, sig);
1537         gcry_md_final (md);
1538
1539         rc = complete_sig (sig, pksk, md);
1540     }
1541
1542     gcry_md_close (md);
1543     if( rc )
1544         free_seckey_enc( sig );
1545     else
1546         *ret_sig = sig;
1547     return rc;
1548 }
1549
1550
1551
1552 /****************
1553  * Create a new signature packet based on an existing one.
1554  * Only user ID signatures are supported for now.
1555  * PK is the public key to work on.
1556  * PKSK is the key used to make the signature.
1557  *
1558  * TODO: Merge this with make_keysig_packet.
1559  */
1560 int
1561 update_keysig_packet( PKT_signature **ret_sig,
1562                       PKT_signature *orig_sig,
1563                       PKT_public_key *pk,
1564                       PKT_user_id *uid, 
1565                       PKT_public_key *subpk,
1566                       PKT_public_key *pksk,
1567                       int (*mksubpkt)(PKT_signature *, void *),
1568                       void *opaque )
1569 {
1570     PKT_signature *sig;
1571     int rc=0;
1572     gcry_md_hd_t md;
1573
1574     if ((!orig_sig || !pk || !pksk)
1575         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1576         || (orig_sig->sig_class == 0x18 && !subpk))
1577       return G10ERR_GENERAL;
1578
1579     if ( gcry_md_open (&md, orig_sig->digest_algo, 0 ) )
1580       BUG ();
1581
1582     /* Hash the public key certificate and the user id. */
1583     hash_public_key( md, pk );
1584
1585     if( orig_sig->sig_class == 0x18 )
1586       hash_public_key( md, subpk );
1587     else
1588       hash_uid (md, orig_sig->version, uid);
1589
1590     /* create a new signature packet */
1591     sig = copy_signature (NULL, orig_sig);
1592  
1593     /* We need to create a new timestamp so that new sig expiration
1594        calculations are done correctly... */
1595     sig->timestamp=make_timestamp();
1596
1597     /* ... but we won't make a timestamp earlier than the existing
1598        one. */
1599     while(sig->timestamp<=orig_sig->timestamp)
1600       {
1601         gnupg_sleep (1);
1602         sig->timestamp=make_timestamp();
1603       }
1604
1605     /* Note that already expired sigs will remain expired (with a
1606        duration of 1) since build-packet.c:build_sig_subpkt_from_sig
1607        detects this case. */
1608
1609     if( sig->version >= 4 )
1610       {
1611         /* Put the updated timestamp into the sig.  Note that this
1612            will automagically lower any sig expiration dates to
1613            correctly correspond to the differences in the timestamps
1614            (i.e. the duration will shrink). */
1615         build_sig_subpkt_from_sig( sig );
1616
1617         if (mksubpkt)
1618           rc = (*mksubpkt)(sig, opaque);
1619       }
1620
1621     if (!rc) {
1622         hash_sigversion_to_magic (md, sig);
1623         gcry_md_final (md);
1624
1625         rc = complete_sig (sig, pksk, md);
1626     }
1627
1628     gcry_md_close (md);
1629     if( rc )
1630         free_seckey_enc (sig);
1631     else
1632         *ret_sig = sig;
1633     return rc;
1634 }