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