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