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