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