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