Removed more secret key related code.
[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
255   if (pksk->timestamp > sig->timestamp )
256     {
257       ulong d = pksk->timestamp - sig->timestamp;
258       log_info (d==1 ? _("key has been created %lu second "
259                          "in future (time warp or clock problem)\n")
260                 : _("key has been created %lu seconds "
261                     "in future (time warp or clock problem)\n"), d );
262       if (!opt.ignore_time_conflict)
263         return gpg_error (GPG_ERR_TIME_CONFLICT);
264     }
265
266   
267   print_pubkey_algo_note (pksk->pubkey_algo);
268
269   if (!mdalgo)
270     mdalgo = gcry_md_get_algo (md);
271
272   print_digest_algo_note (mdalgo);
273   dp = gcry_md_read  (md, mdalgo);
274   sig->digest_algo = mdalgo;
275   sig->digest_start[0] = dp[0];
276   sig->digest_start[1] = dp[1];
277   sig->data[0] = NULL;
278   sig->data[1] = NULL;
279
280 #warning fixme: Use the agent for the card
281 /*     if (pksk->is_protected && pksk->protect.s2k.mode == 1002)  */
282 /*       {  */
283 /* #ifdef ENABLE_CARD_SUPPORT */
284 /*         unsigned char *rbuf; */
285 /*         size_t rbuflen; */
286 /*         char *snbuf; */
287         
288 /*         snbuf = serialno_and_fpr_from_sk (sk->protect.iv, */
289 /*                                           sk->protect.ivlen, sk); */
290 /*         rc = agent_scd_pksign (snbuf, digest_algo, */
291 /*                                gcry_md_read (md, digest_algo), */
292 /*                                gcry_md_get_algo_dlen (digest_algo), */
293 /*                                &rbuf, &rbuflen); */
294 /*         xfree (snbuf); */
295 /*         if (!rc) */
296 /*           { */
297 /*             if (gcry_mpi_scan (&sig->data[0], GCRYMPI_FMT_USG, */
298 /*                                rbuf, rbuflen, NULL)) */
299 /*               BUG (); */
300 /*             xfree (rbuf); */
301 /*           } */
302 /* #else */
303 /*         return gpg_error (GPG_ERR_NOT_SUPPORTED); */
304 /* #endif /\* ENABLE_CARD_SUPPORT *\/ */
305 /*       } */
306 /*     else  */
307   if (1)
308     {
309       char *hexgrip;
310       
311       err = hexkeygrip_from_pk (pksk, &hexgrip);
312       if (!err)
313         {
314           char *desc;
315           gcry_sexp_t s_sigval;
316           
317           desc = gpg_format_keydesc (pksk, 0, 1);
318           err = agent_pksign (NULL/*ctrl*/, cache_nonce, hexgrip, desc, 
319                               dp, gcry_md_get_algo_dlen (mdalgo), mdalgo,
320                               &s_sigval);
321           xfree (desc);
322      
323           if (err)
324             ;
325           else if (pksk->pubkey_algo == GCRY_PK_RSA
326                    || pksk->pubkey_algo == GCRY_PK_RSA_S)
327             sig->data[0] = mpi_from_sexp (s_sigval, "s");
328           else
329             {
330               sig->data[0] = mpi_from_sexp (s_sigval, "r");
331               sig->data[1] = mpi_from_sexp (s_sigval, "s");
332             }
333       
334           gcry_sexp_release (s_sigval);
335         }
336       xfree (hexgrip);
337     }
338
339   /* Check that the signature verification worked and nothing is
340    * fooling us e.g. by a bug in the signature create code or by
341    * deliberately introduced faults.  */
342   if (!err && !opt.no_sig_create_check)
343     {
344       PKT_public_key *pk = xmalloc_clear (sizeof *pk);
345
346       if (get_pubkey (pk, sig->keyid ))
347         err = gpg_error (GPG_ERR_NO_PUBKEY);
348       else 
349         {
350           frame = encode_md_value (pk, md, sig->digest_algo );
351           if (!frame)
352             err = gpg_error (GPG_ERR_GENERAL);
353           else
354             err = pk_verify (pk->pubkey_algo, frame, sig->data, pk->pkey);
355           gcry_mpi_release (frame);
356         }
357       if (err)
358         log_error (_("checking created signature failed: %s\n"),
359                    g10_errstr (err));
360       free_public_key (pk);
361     }
362
363   if (err)
364     log_error (_("signing failed: %s\n"), g10_errstr (err));
365   else 
366     {
367       if (opt.verbose)
368         {
369           char *ustr = get_user_id_string_native (sig->keyid);
370           log_info (_("%s/%s signature from: \"%s\"\n"),
371                     gcry_pk_algo_name (pksk->pubkey_algo),
372                     gcry_md_algo_name (sig->digest_algo),
373                     ustr);
374           xfree (ustr);
375         }
376     }
377   return err;
378 }
379
380
381 int
382 complete_sig (PKT_signature *sig, PKT_public_key *pksk, gcry_md_hd_t md,
383               const char *cache_nonce)
384 {
385   int rc;
386
387   /* if (!(rc = check_secret_key (pksk, 0))) */
388   rc = do_sign (pksk, sig, md, 0, cache_nonce);
389   return rc;
390 }
391
392
393
394 static int
395 match_dsa_hash (unsigned int qbytes)
396 {
397   if (qbytes <= 20)
398     return DIGEST_ALGO_SHA1;
399
400   if (qbytes <= 28)
401     return DIGEST_ALGO_SHA224;
402
403   if (qbytes <= 32)
404     return DIGEST_ALGO_SHA256;
405
406   if (qbytes <= 48)
407     return DIGEST_ALGO_SHA384;
408
409   if (qbytes <= 64)
410     return DIGEST_ALGO_SHA512;
411
412   return DEFAULT_DIGEST_ALGO;
413   /* DEFAULT_DIGEST_ALGO will certainly fail, but it's the best wrong
414      answer we have if a digest larger than 512 bits is requested.  */
415 }
416
417
418 /*
419   First try --digest-algo.  If that isn't set, see if the recipient
420   has a preferred algorithm (which is also filtered through
421   --preferred-digest-prefs).  If we're making a signature without a
422   particular recipient (i.e. signing, rather than signing+encrypting)
423   then take the first algorithm in --preferred-digest-prefs that is
424   usable for the pubkey algorithm.  If --preferred-digest-prefs isn't
425   set, then take the OpenPGP default (i.e. SHA-1).
426
427   Possible improvement: Use the highest-ranked usable algorithm from
428   the signing key prefs either before or after using the personal
429   list?
430 */
431 static int
432 hash_for (PKT_public_key *pk)
433 {
434   if (opt.def_digest_algo)
435     {
436       return opt.def_digest_algo;
437     }
438   else if (recipient_digest_algo)
439     {
440       return recipient_digest_algo;
441     }
442   else if (pk->pubkey_algo == PUBKEY_ALGO_DSA)
443     {
444       unsigned int qbytes = gcry_mpi_get_nbits (pk->pkey[1]) / 8;
445
446       /* It's a DSA key, so find a hash that is the same size as q or
447          larger.  If q is 160, assume it is an old DSA key and use a
448          160-bit hash unless --enable-dsa2 is set, in which case act
449          like a new DSA key that just happens to have a 160-bit q
450          (i.e. allow truncation).  If q is not 160, by definition it
451          must be a new DSA key. */
452
453       if (opt.personal_digest_prefs)
454         {
455           prefitem_t *prefs;
456
457           if (qbytes != 20 || opt.flags.dsa2)
458             {
459               for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
460                 if (gcry_md_get_algo_dlen (prefs->value) >= qbytes)
461                   return prefs->value;
462             }
463           else
464             {
465               for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
466                 if (gcry_md_get_algo_dlen (prefs->value) == qbytes)
467                   return prefs->value;
468             }
469         }
470
471       return match_dsa_hash(qbytes);
472     }
473   else if (0 
474            /* FIXME: call agent sk->is_protected && sk->protect.s2k.mode == 1002
475            && sk->protect.ivlen == 16
476            && !memcmp (sk->protect.iv, "\xD2\x76\x00\x01\x24\x01\x01", 7)*/)
477     {
478       /* The sk lives on a smartcard, and old smartcards only handle
479          SHA-1 and RIPEMD/160.  Newer smartcards (v2.0) don't have
480          this restriction anymore.  Fortunately the serial number
481          encodes the version of the card and thus we know that this
482          key is on a v1 card. */
483       if(opt.personal_digest_prefs)
484         {
485           prefitem_t *prefs;
486
487           for (prefs=opt.personal_digest_prefs;prefs->type;prefs++)
488             if (prefs->value==DIGEST_ALGO_SHA1
489                 || prefs->value==DIGEST_ALGO_RMD160)
490               return prefs->value;
491         }
492
493       return DIGEST_ALGO_SHA1;
494     }
495   else if (PGP2 && pk->pubkey_algo == PUBKEY_ALGO_RSA && pk->version < 4 )
496     {
497       /* Old-style PGP only understands MD5 */
498       return DIGEST_ALGO_MD5;
499     }
500   else if (opt.personal_digest_prefs)
501     {
502       /* It's not DSA, so we can use whatever the first hash algorithm
503          is in the pref list */
504       return opt.personal_digest_prefs[0].value;
505     }
506   else
507     return DEFAULT_DIGEST_ALGO;
508 }
509
510
511 /* Return true iff all keys in SK_LIST are old style (v3 RSA).  */
512 static int
513 only_old_style (SK_LIST sk_list)
514 {
515   SK_LIST sk_rover = NULL;
516   int old_style = 0;
517   
518   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
519     {
520       PKT_public_key *pk = sk_rover->pk;
521
522       if (pk->pubkey_algo == PUBKEY_ALGO_RSA && pk->version < 4)
523         old_style = 1;
524       else
525         return 0;
526     }
527   return old_style;
528 }
529
530
531 static void
532 print_status_sig_created (PKT_public_key *pk, PKT_signature *sig, int what)
533 {
534   byte array[MAX_FINGERPRINT_LEN];
535   char buf[100+MAX_FINGERPRINT_LEN*2];
536   size_t n;
537   
538   snprintf (buf, sizeof buf - 2*MAX_FINGERPRINT_LEN, "%c %d %d %02x %lu ",
539             what, sig->pubkey_algo, sig->digest_algo, sig->sig_class,
540             (ulong)sig->timestamp );
541   fingerprint_from_pk (pk, array, &n);
542   bin2hex (array, n, buf + strlen (buf));
543   
544   write_status_text( STATUS_SIG_CREATED, buf );
545 }
546
547
548 /*
549  * Loop over the secret certificates in SK_LIST and build the one pass
550  * signature packets.  OpenPGP says that the data should be bracket by
551  * the onepass-sig and signature-packet; so we build these onepass
552  * packet here in reverse order 
553  */
554 static int
555 write_onepass_sig_packets (SK_LIST sk_list, IOBUF out, int sigclass )
556 {
557     int skcount;
558     SK_LIST sk_rover;
559
560     for (skcount=0, sk_rover=sk_list; sk_rover; sk_rover = sk_rover->next)
561         skcount++;
562
563     for (; skcount; skcount--) {
564         PKT_public_key *pk;
565         PKT_onepass_sig *ops;
566         PACKET pkt;
567         int i, rc;
568         
569         for (i=0, sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
570             if (++i == skcount)
571                 break;
572         }
573
574         pk = sk_rover->pk;
575         ops = xmalloc_clear (sizeof *ops);
576         ops->sig_class = sigclass;
577         ops->digest_algo = hash_for (pk);
578         ops->pubkey_algo = pk->pubkey_algo;
579         keyid_from_pk (pk, ops->keyid);
580         ops->last = (skcount == 1);
581         
582         init_packet(&pkt);
583         pkt.pkttype = PKT_ONEPASS_SIG;
584         pkt.pkt.onepass_sig = ops;
585         rc = build_packet (out, &pkt);
586         free_packet (&pkt);
587         if (rc) {
588             log_error ("build onepass_sig packet failed: %s\n",
589                        g10_errstr(rc));
590             return rc;
591         }
592     }
593
594     return 0;
595 }
596
597 /*
598  * Helper to write the plaintext (literal data) packet
599  */
600 static int
601 write_plaintext_packet (IOBUF out, IOBUF inp, const char *fname, int ptmode)
602 {
603     PKT_plaintext *pt = NULL;
604     u32 filesize;
605     int rc = 0;
606
607     if (!opt.no_literal)
608       pt=setup_plaintext_name(fname,inp);
609
610     /* try to calculate the length of the data */
611     if ( !iobuf_is_pipe_filename (fname) && *fname )
612       {
613         off_t tmpsize;
614         int overflow;
615
616         if( !(tmpsize = iobuf_get_filelength(inp, &overflow))
617             && !overflow && opt.verbose)
618           log_info (_("WARNING: `%s' is an empty file\n"), fname);
619
620         /* We can't encode the length of very large files because
621            OpenPGP uses only 32 bit for file sizes.  So if the size of
622            a file is larger than 2^32 minus some bytes for packet
623            headers, we switch to partial length encoding. */
624         if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
625           filesize = tmpsize;
626         else
627           filesize = 0;
628
629         /* Because the text_filter modifies the length of the
630          * data, it is not possible to know the used length
631          * without a double read of the file - to avoid that
632          * we simple use partial length packets. */
633         if ( ptmode == 't' )
634           filesize = 0;
635       }
636     else
637       filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
638
639     if (!opt.no_literal) {
640         PACKET pkt;
641
642         pt->timestamp = make_timestamp ();
643         pt->mode = ptmode;
644         pt->len = filesize;
645         pt->new_ctb = !pt->len && !RFC1991;
646         pt->buf = inp;
647         init_packet(&pkt);
648         pkt.pkttype = PKT_PLAINTEXT;
649         pkt.pkt.plaintext = pt;
650         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
651         if( (rc = build_packet (out, &pkt)) )
652             log_error ("build_packet(PLAINTEXT) failed: %s\n",
653                        g10_errstr(rc) );
654         pt->buf = NULL;
655     }
656     else {
657         byte copy_buffer[4096];
658         int  bytes_copied;
659
660         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
661             if ( (rc=iobuf_write(out, copy_buffer, bytes_copied)) ) {
662                 log_error ("copying input to output failed: %s\n",
663                            gpg_strerror (rc));
664                 break;
665             }
666         wipememory(copy_buffer,4096); /* burn buffer */
667     }
668     /* fixme: it seems that we never freed pt/pkt */
669     
670     return rc;
671 }
672
673 /*
674  * Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
675  * hash which will not be changes here.
676  */
677 static int
678 write_signature_packets (SK_LIST sk_list, IOBUF out, gcry_md_hd_t hash,
679                          int sigclass, u32 timestamp, u32 duration,
680                          int status_letter, const char *cache_nonce)
681 {
682   SK_LIST sk_rover;
683   
684   /* Loop over the certificates with secret keys. */
685   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
686     {
687       PKT_public_key *pk;
688       PKT_signature *sig;
689       gcry_md_hd_t md;
690       int rc;
691
692       pk = sk_rover->pk;
693
694       /* Build the signature packet.  */
695       sig = xmalloc_clear (sizeof *sig);
696       if (opt.force_v3_sigs || RFC1991)
697         sig->version = 3;
698       else if (duration || opt.sig_policy_url
699                || opt.sig_notations || opt.sig_keyserver_url)
700         sig->version = 4;
701       else
702         sig->version = pk->version;
703
704       keyid_from_pk (pk, sig->keyid);
705       sig->digest_algo = hash_for (pk);
706       sig->pubkey_algo = pk->pubkey_algo;
707       if (timestamp)
708         sig->timestamp = timestamp;
709       else
710         sig->timestamp = make_timestamp();
711       if (duration)
712         sig->expiredate = sig->timestamp + duration;
713       sig->sig_class = sigclass;
714
715       if (gcry_md_copy (&md, hash))
716         BUG ();
717       
718       if (sig->version >= 4)
719         {
720           build_sig_subpkt_from_sig (sig);
721           mk_notation_policy_etc (sig, pk, NULL);
722         }
723       
724       hash_sigversion_to_magic (md, sig);
725       gcry_md_final (md);
726
727       rc = do_sign (pk, sig, md, hash_for (pk), cache_nonce);
728       gcry_md_close (md);
729       if (!rc)
730         { 
731           /* Write the packet.  */
732           PACKET pkt;
733           
734           init_packet (&pkt);
735           pkt.pkttype = PKT_SIGNATURE;
736           pkt.pkt.signature = sig;
737           rc = build_packet (out, &pkt);
738           if (!rc && is_status_enabled())
739             print_status_sig_created (pk, sig, status_letter);
740           free_packet (&pkt);
741           if (rc)
742             log_error ("build signature packet failed: %s\n", gpg_strerror (rc));
743         }
744       if (rc)
745         return rc;
746     }
747   
748   return 0;
749 }
750
751
752 /****************
753  * Sign the files whose names are in FILENAME.
754  * If DETACHED has the value true,
755  * make a detached signature.  If FILENAMES->d is NULL read from stdin
756  * and ignore the detached mode.  Sign the file with all secret keys
757  * which can be taken from LOCUSR, if this is NULL, use the default one
758  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
759  * signed data for these users.
760  * If OUTFILE is not NULL; this file is used for output and the function
761  * does not ask for overwrite permission; output is then always
762  * uncompressed, non-armored and in binary mode.
763  */
764 int
765 sign_file( strlist_t filenames, int detached, strlist_t locusr,
766            int encryptflag, strlist_t remusr, const char *outfile )
767 {
768     const char *fname;
769     armor_filter_context_t *afx;
770     compress_filter_context_t zfx;
771     md_filter_context_t mfx;
772     text_filter_context_t tfx;
773     progress_filter_context_t *pfx;
774     encrypt_filter_context_t efx;
775     IOBUF inp = NULL, out = NULL;
776     PACKET pkt;
777     int rc = 0;
778     PK_LIST pk_list = NULL;
779     SK_LIST sk_list = NULL;
780     SK_LIST sk_rover = NULL;
781     int multifile = 0;
782     u32 duration=0;
783
784     pfx = new_progress_context ();
785     afx = new_armor_context ();
786     memset( &zfx, 0, sizeof zfx);
787     memset( &mfx, 0, sizeof mfx);
788     memset( &efx, 0, sizeof efx);
789     init_packet( &pkt );
790
791     if( filenames ) {
792         fname = filenames->d;
793         multifile = !!filenames->next;
794     }
795     else
796         fname = NULL;
797
798     if( fname && filenames->next && (!detached || encryptflag) )
799         log_bug("multiple files can only be detached signed");
800
801     if(encryptflag==2
802        && (rc=setup_symkey(&efx.symkey_s2k,&efx.symkey_dek)))
803       goto leave;
804
805     if(!opt.force_v3_sigs && !RFC1991)
806       {
807         if(opt.ask_sig_expire && !opt.batch)
808           duration=ask_expire_interval(1,opt.def_sig_expire);
809         else
810           duration=parse_expire_string(opt.def_sig_expire);
811       }
812
813     /* Note: In the old non-agent version the following call used to
814        unprotect the secret key.  This is now done on demand by the agent.  */
815     if( (rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG )) )
816         goto leave;
817
818     if(PGP2 && !only_old_style(sk_list))
819       {
820         log_info(_("you can only detach-sign with PGP 2.x style keys "
821                    "while in --pgp2 mode\n"));
822         compliance_failure();
823       }
824
825     if(encryptflag && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
826       goto leave;
827
828     /* prepare iobufs */
829     if( multifile )  /* have list of filenames */
830         inp = NULL; /* we do it later */
831     else {
832       inp = iobuf_open(fname);
833       if (inp && is_secured_file (iobuf_get_fd (inp)))
834         {
835           iobuf_close (inp);
836           inp = NULL;
837           gpg_err_set_errno (EPERM);
838         }
839       if( !inp ) 
840         {
841           rc = gpg_error_from_syserror ();
842           log_error (_("can't open `%s': %s\n"), fname? fname: "[stdin]",
843                      strerror(errno) );
844           goto leave;
845         }
846
847         handle_progress (pfx, inp, fname);
848     }
849
850     if( outfile ) {
851         if (is_secured_filename ( outfile )) {
852             out = NULL;
853             gpg_err_set_errno (EPERM);
854         }
855         else
856             out = iobuf_create( outfile );
857         if( !out )
858           {
859             rc = gpg_error_from_syserror ();
860             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
861             goto leave;
862           }
863         else if( opt.verbose )
864             log_info(_("writing to `%s'\n"), outfile );
865     }
866     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname,
867                                  opt.armor? 1: detached? 2:0, &out )))
868         goto leave;
869
870     /* prepare to calculate the MD over the input */
871     if( opt.textmode && !outfile && !multifile )
872       {
873         memset( &tfx, 0, sizeof tfx);
874         iobuf_push_filter( inp, text_filter, &tfx );
875       }
876
877     if ( gcry_md_open (&mfx.md, 0, 0) )
878       BUG ();
879     if (DBG_HASHING)
880       gcry_md_start_debug (mfx.md, "sign");
881
882     /* If we're encrypting and signing, it is reasonable to pick the
883        hash algorithm to use out of the recepient key prefs.  This is
884        best effort only, as in a DSA2 and smartcard world there are
885        cases where we cannot please everyone with a single hash (DSA2
886        wants >160 and smartcards want =160).  In the future this could
887        be more complex with different hashes for each sk, but the
888        current design requires a single hash for all SKs. */
889     if(pk_list)
890       {
891         if(opt.def_digest_algo)
892           {
893             if(!opt.expert &&
894                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
895                                       opt.def_digest_algo,
896                                       NULL)!=opt.def_digest_algo)
897           log_info(_("WARNING: forcing digest algorithm %s (%d)"
898                      " violates recipient preferences\n"),
899                    gcry_md_algo_name (opt.def_digest_algo),
900                    opt.def_digest_algo );
901           }
902         else
903           {
904             int algo, smartcard=0;
905             union pref_hint hint;
906
907             hint.digest_length = 0;
908
909             /* Of course, if the recipient asks for something
910                unreasonable (like the wrong hash for a DSA key) then
911                don't do it.  Check all sk's - if any are DSA or live
912                on a smartcard, then the hash has restrictions and we
913                may not be able to give the recipient what they want.
914                For DSA, pass a hint for the largest q we have.  Note
915                that this means that a q>160 key will override a q=160
916                key and force the use of truncation for the q=160 key.
917                The alternative would be to ignore the recipient prefs
918                completely and get a different hash for each DSA key in
919                hash_for().  The override behavior here is more or less
920                reasonable as it is under the control of the user which
921                keys they sign with for a given message and the fact
922                that the message with multiple signatures won't be
923                usable on an implementation that doesn't understand
924                DSA2 anyway. */
925
926             for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
927               {
928                 if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_DSA)
929                   {
930                     int temp_hashlen = gcry_mpi_get_nbits
931                       (sk_rover->pk->pkey[1])+7/8;
932
933                     /* Pick a hash that is large enough for our
934                        largest q */
935
936                     if (hint.digest_length<temp_hashlen)
937                       hint.digest_length=temp_hashlen;
938                   }
939                 /* FIXME: need toall gpg-agent */
940                 /* else if (sk_rover->pk->is_protected */
941                 /*          && sk_rover->pk->protect.s2k.mode == 1002) */
942                 /*   smartcard = 1;  */
943               }
944
945             /* Current smartcards only do 160-bit hashes.  If we have
946                to have a >160-bit hash, then we can't use the
947                recipient prefs as we'd need both =160 and >160 at the
948                same time and recipient prefs currently require a
949                single hash for all signatures.  All this may well have
950                to change as the cards add algorithms. */
951
952             if (!smartcard || (smartcard && hint.digest_length==20))
953               if ( (algo=
954                    select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint)) > 0)
955                 recipient_digest_algo=algo;
956           }
957       }
958
959     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
960       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
961
962     if( !multifile )
963         iobuf_push_filter( inp, md_filter, &mfx );
964
965     if( detached && !encryptflag && !RFC1991 )
966         afx->what = 2;
967
968     if( opt.armor && !outfile  )
969         push_armor_filter (afx, out);
970
971     if( encryptflag ) {
972         efx.pk_list = pk_list;
973         /* fixme: set efx.cfx.datalen if known */
974         iobuf_push_filter( out, encrypt_filter, &efx );
975     }
976
977     if( opt.compress_algo && !outfile && ( !detached || opt.compress_sigs) )
978       {
979         int compr_algo=opt.compress_algo;
980
981         /* If not forced by user */
982         if(compr_algo==-1)
983           {
984             /* If we're not encrypting, then select_algo_from_prefs
985                will fail and we'll end up with the default.  If we are
986                encrypting, select_algo_from_prefs cannot fail since
987                there is an assumed preference for uncompressed data.
988                Still, if it did fail, we'll also end up with the
989                default. */
990  
991             if((compr_algo=
992                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
993               compr_algo=default_compress_algo();
994           }
995         else if(!opt.expert && pk_list
996                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
997                                           compr_algo,NULL)!=compr_algo)
998           log_info(_("WARNING: forcing compression algorithm %s (%d)"
999                      " violates recipient preferences\n"),
1000                    compress_algo_to_string(compr_algo),compr_algo);
1001
1002         /* algo 0 means no compression */
1003         if( compr_algo )
1004           push_compress_filter(out,&zfx,compr_algo);
1005       }
1006
1007     /* Write the one-pass signature packets if needed */
1008     if (!detached && !RFC1991) {
1009         rc = write_onepass_sig_packets (sk_list, out,
1010                                         opt.textmode && !outfile ? 0x01:0x00);
1011         if (rc)
1012             goto leave;
1013     }
1014
1015     write_status_begin_signing (mfx.md);
1016
1017     /* Setup the inner packet. */
1018     if( detached ) {
1019         if( multifile ) {
1020             strlist_t sl;
1021
1022             if( opt.verbose )
1023                 log_info(_("signing:") );
1024             /* must walk reverse trough this list */
1025             for( sl = strlist_last(filenames); sl;
1026                         sl = strlist_prev( filenames, sl ) ) {
1027                 inp = iobuf_open(sl->d);
1028                 if (inp && is_secured_file (iobuf_get_fd (inp)))
1029                   {
1030                     iobuf_close (inp);
1031                     inp = NULL;
1032                     gpg_err_set_errno (EPERM);
1033                   }
1034                 if( !inp )
1035                   {
1036                     rc = gpg_error_from_syserror ();
1037                     log_error(_("can't open `%s': %s\n"),
1038                               sl->d,strerror(errno));
1039                     goto leave;
1040                   }
1041                 handle_progress (pfx, inp, sl->d);
1042                 if( opt.verbose )
1043                     fprintf(stderr, " `%s'", sl->d );
1044                 if(opt.textmode)
1045                   {
1046                     memset( &tfx, 0, sizeof tfx);
1047                     iobuf_push_filter( inp, text_filter, &tfx );
1048                   }
1049                 iobuf_push_filter( inp, md_filter, &mfx );
1050                 while( iobuf_get(inp) != -1 )
1051                     ;
1052                 iobuf_close(inp); inp = NULL;
1053             }
1054             if( opt.verbose )
1055                 putc( '\n', stderr );
1056         }
1057         else {
1058             /* read, so that the filter can calculate the digest */
1059             while( iobuf_get(inp) != -1 )
1060                 ;
1061         }
1062     }
1063     else {
1064         rc = write_plaintext_packet (out, inp, fname,
1065                                      opt.textmode && !outfile ? 't':'b');
1066     }
1067
1068     /* catch errors from above */
1069     if (rc)
1070         goto leave;
1071
1072     /* write the signatures */
1073     rc = write_signature_packets (sk_list, out, mfx.md,
1074                                   opt.textmode && !outfile? 0x01 : 0x00,
1075                                   0, duration, detached ? 'D':'S', NULL);
1076     if( rc )
1077         goto leave;
1078
1079
1080   leave:
1081     if( rc )
1082         iobuf_cancel(out);
1083     else {
1084         iobuf_close(out);
1085         if (encryptflag)
1086             write_status( STATUS_END_ENCRYPTION );
1087     }
1088     iobuf_close(inp);
1089     gcry_md_close ( mfx.md );
1090     release_sk_list( sk_list );
1091     release_pk_list( pk_list );
1092     recipient_digest_algo=0;
1093     release_progress_context (pfx);
1094     release_armor_context (afx);
1095     return rc;
1096 }
1097
1098
1099
1100 /****************
1101  * make a clear signature. note that opt.armor is not needed
1102  */
1103 int
1104 clearsign_file( const char *fname, strlist_t locusr, const char *outfile )
1105 {
1106     armor_filter_context_t *afx;
1107     progress_filter_context_t *pfx;
1108     gcry_md_hd_t textmd = NULL;
1109     IOBUF inp = NULL, out = NULL;
1110     PACKET pkt;
1111     int rc = 0;
1112     SK_LIST sk_list = NULL;
1113     SK_LIST sk_rover = NULL;
1114     int old_style = RFC1991;
1115     int only_md5 = 0;
1116     u32 duration=0;
1117
1118     pfx = new_progress_context ();
1119     afx = new_armor_context ();
1120     init_packet( &pkt );
1121
1122     if(!opt.force_v3_sigs && !RFC1991)
1123       {
1124         if(opt.ask_sig_expire && !opt.batch)
1125           duration=ask_expire_interval(1,opt.def_sig_expire);
1126         else
1127           duration=parse_expire_string(opt.def_sig_expire);
1128       }
1129
1130     /* Note: In the old non-agent version the following call used to
1131        unprotect the secret key.  This is now done on demand by the agent.  */
1132     if( (rc=build_sk_list( locusr, &sk_list, PUBKEY_USAGE_SIG )) )
1133         goto leave;
1134
1135     if( !old_style && !duration )
1136         old_style = only_old_style( sk_list );
1137
1138     if(PGP2 && !only_old_style(sk_list))
1139       {
1140         log_info(_("you can only clearsign with PGP 2.x style keys "
1141                    "while in --pgp2 mode\n"));
1142         compliance_failure();
1143       }
1144
1145     /* prepare iobufs */
1146     inp = iobuf_open(fname);
1147     if (inp && is_secured_file (iobuf_get_fd (inp)))
1148       {
1149         iobuf_close (inp);
1150         inp = NULL;
1151         gpg_err_set_errno (EPERM);
1152       }
1153     if( !inp ) {
1154         rc = gpg_error_from_syserror ();
1155         log_error (_("can't open `%s': %s\n"), 
1156                    fname? fname: "[stdin]", strerror(errno) );
1157         goto leave;
1158     }
1159     handle_progress (pfx, inp, fname);
1160
1161     if( outfile ) {
1162         if (is_secured_filename (outfile) ) {
1163             outfile = NULL;
1164             gpg_err_set_errno (EPERM);
1165         }
1166         else 
1167             out = iobuf_create( outfile );
1168         if( !out )
1169           {
1170             rc = gpg_error_from_syserror ();
1171             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
1172             goto leave;
1173           }
1174         else if( opt.verbose )
1175             log_info(_("writing to `%s'\n"), outfile );
1176     }
1177     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname, 1, &out )) )
1178         goto leave;
1179
1180     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1181
1182     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1183       {
1184         if (hash_for (sk_rover->pk) == DIGEST_ALGO_MD5)
1185           only_md5 = 1;
1186         else 
1187           {
1188             only_md5 = 0;
1189             break;
1190           }
1191       }
1192
1193     if( !(old_style && only_md5) ) {
1194         const char *s;
1195         int any = 0;
1196         byte hashs_seen[256];
1197
1198         memset( hashs_seen, 0, sizeof hashs_seen );
1199         iobuf_writestr(out, "Hash: " );
1200         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1201             int i = hash_for (sk_rover->pk);
1202
1203             if( !hashs_seen[ i & 0xff ] ) {
1204                 s = gcry_md_algo_name ( i );
1205                 if( s ) {
1206                     hashs_seen[ i & 0xff ] = 1;
1207                     if( any )
1208                         iobuf_put(out, ',' );
1209                     iobuf_writestr(out, s );
1210                     any = 1;
1211                 }
1212             }
1213         }
1214         assert(any);
1215         iobuf_writestr(out, LF );
1216     }
1217
1218     if( opt.not_dash_escaped )
1219       iobuf_writestr( out,
1220                   "NotDashEscaped: You need GnuPG to verify this message" LF );
1221     iobuf_writestr(out, LF );
1222
1223     if ( gcry_md_open (&textmd, 0, 0) )
1224       BUG ();
1225     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1226       gcry_md_enable (textmd, hash_for(sk_rover->pk));
1227
1228     if ( DBG_HASHING )
1229       gcry_md_start_debug ( textmd, "clearsign" );
1230
1231     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
1232                         opt.escape_from, (old_style && only_md5) );
1233     /* fixme: check for read errors */
1234
1235     /* now write the armor */
1236     afx->what = 2;
1237     push_armor_filter (afx, out);
1238
1239     /* Write the signatures.  */
1240     rc = write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C',
1241                                   NULL);
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', NULL);
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                     const char *cache_nonce)
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, cache_nonce);
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, NULL);
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 }