gpg: Make function mk_datestr public.
[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  * Create notations and other stuff.  It is assumed that the stings in
56  * STRLIST are already checked to contain only printable data and have
57  * a valid NAME=VALUE format.
58  */
59 static void
60 mk_notation_policy_etc (PKT_signature *sig,
61                         PKT_public_key *pk, PKT_public_key *pksk)
62 {
63   const char *string;
64   char *p = NULL;
65   strlist_t pu = NULL;
66   struct notation *nd = NULL;
67   struct expando_args args;
68
69   log_assert (sig->version >= 4);
70
71   memset (&args, 0, sizeof(args));
72   args.pk = pk;
73   args.pksk = pksk;
74
75   /* Notation data. */
76   if (IS_SIG(sig) && opt.sig_notations)
77     nd = opt.sig_notations;
78   else if (IS_CERT(sig) && opt.cert_notations)
79     nd = opt.cert_notations;
80
81   if (nd)
82     {
83       struct notation *item;
84
85       for (item = nd; item; item = item->next)
86         {
87           item->altvalue = pct_expando (item->value,&args);
88           if (!item->altvalue)
89             log_error (_("WARNING: unable to %%-expand notation "
90                          "(too large).  Using unexpanded.\n"));
91         }
92
93       keygen_add_notations (sig, nd);
94
95       for (item = nd; item; item = item->next)
96         {
97           xfree (item->altvalue);
98           item->altvalue = NULL;
99         }
100     }
101
102   /* Set policy URL. */
103   if (IS_SIG(sig) && opt.sig_policy_url)
104     pu = opt.sig_policy_url;
105   else if (IS_CERT(sig) && opt.cert_policy_url)
106     pu = opt.cert_policy_url;
107
108   for (; pu; pu = pu->next)
109     {
110       string = pu->d;
111
112       p = pct_expando (string, &args);
113       if (!p)
114         {
115           log_error(_("WARNING: unable to %%-expand policy URL "
116                       "(too large).  Using unexpanded.\n"));
117           p = xstrdup(string);
118         }
119
120       build_sig_subpkt (sig, (SIGSUBPKT_POLICY
121                               | ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0)),
122                         p, strlen (p));
123
124       xfree (p);
125     }
126
127   /* Preferred keyserver URL. */
128   if (IS_SIG(sig) && opt.sig_keyserver_url)
129     pu = opt.sig_keyserver_url;
130
131   for (; pu; pu = pu->next)
132     {
133       string = pu->d;
134
135       p = pct_expando (string, &args);
136       if (!p)
137         {
138           log_error (_("WARNING: unable to %%-expand preferred keyserver URL"
139                        " (too large).  Using unexpanded.\n"));
140           p = xstrdup (string);
141         }
142
143       build_sig_subpkt (sig, (SIGSUBPKT_PREF_KS
144                               | ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0)),
145                         p, strlen (p));
146       xfree (p);
147     }
148
149   /* Set signer's user id.  */
150   if (IS_SIG (sig) && !opt.flags.disable_signer_uid)
151     {
152       char *mbox;
153
154       /* For now we use the uid which was used to locate the key.  */
155       if (pksk->user_id && (mbox = mailbox_from_userid (pksk->user_id->name)))
156         {
157           if (DBG_LOOKUP)
158             log_debug ("setting Signer's UID to '%s'\n", mbox);
159           build_sig_subpkt (sig, SIGSUBPKT_SIGNERS_UID, mbox, strlen (mbox));
160           xfree (mbox);
161         }
162       else if (opt.sender_list)
163         {
164           /* If a list of --sender was given we scan that list and use
165            * the first one matching a user id of the current key.  */
166
167           /* FIXME: We need to get the list of user ids for the PKSK
168            * packet.  That requires either a function to look it up
169            * again or we need to extend the key packet struct to link
170            * to the primary key which in turn could link to the user
171            * ids.  Too much of a change right now.  Let's take just
172            * one from the supplied list and hope that the caller
173            * passed a matching one.  */
174           build_sig_subpkt (sig, SIGSUBPKT_SIGNERS_UID,
175                             opt.sender_list->d, strlen (opt.sender_list->d));
176         }
177     }
178 }
179
180
181 /*
182  * Helper to hash a user ID packet.
183  */
184 static void
185 hash_uid (gcry_md_hd_t md, int sigversion, const PKT_user_id *uid)
186 {
187   byte buf[5];
188
189   (void)sigversion;
190
191   if (uid->attrib_data)
192     {
193       buf[0] = 0xd1;                   /* Indicates an attribute packet.  */
194       buf[1] = uid->attrib_len >> 24;  /* Always use 4 length bytes.  */
195       buf[2] = uid->attrib_len >> 16;
196       buf[3] = uid->attrib_len >>  8;
197       buf[4] = uid->attrib_len;
198     }
199   else
200     {
201       buf[0] = 0xb4;                   /* Indicates a userid packet.  */
202       buf[1] = uid->len >> 24;         /* Always use 4 length bytes.  */
203       buf[2] = uid->len >> 16;
204       buf[3] = uid->len >>  8;
205       buf[4] = uid->len;
206     }
207   gcry_md_write( md, buf, 5 );
208
209   if (uid->attrib_data)
210     gcry_md_write (md, uid->attrib_data, uid->attrib_len );
211   else
212     gcry_md_write (md, uid->name, uid->len );
213 }
214
215
216 /*
217  * Helper to hash some parts from the signature
218  */
219 static void
220 hash_sigversion_to_magic (gcry_md_hd_t md, const PKT_signature *sig)
221 {
222   byte buf[6];
223   size_t n;
224
225   gcry_md_putc (md, sig->version);
226   gcry_md_putc (md, sig->sig_class);
227   gcry_md_putc (md, sig->pubkey_algo);
228   gcry_md_putc (md, sig->digest_algo);
229   if (sig->hashed)
230     {
231       n = sig->hashed->len;
232       gcry_md_putc (md, (n >> 8) );
233       gcry_md_putc (md,  n       );
234       gcry_md_write (md, sig->hashed->data, n );
235       n += 6;
236     }
237   else
238     {
239       gcry_md_putc (md, 0);  /* Always hash the length of the subpacket.  */
240       gcry_md_putc (md, 0);
241       n = 6;
242     }
243   /* Add some magic.  */
244   buf[0] = sig->version;
245   buf[1] = 0xff;
246   buf[2] = n >> 24;         /* (n is only 16 bit, so this is always 0) */
247   buf[3] = n >> 16;
248   buf[4] = n >>  8;
249   buf[5] = n;
250   gcry_md_write (md, buf, 6);
251 }
252
253
254 /* Perform the sign operation.  If CACHE_NONCE is given the agent is
255    advised to use that cached passphrase for the key.  */
256 static int
257 do_sign (ctrl_t ctrl, PKT_public_key *pksk, PKT_signature *sig,
258          gcry_md_hd_t md, int mdalgo, const char *cache_nonce)
259 {
260   gpg_error_t err;
261   byte *dp;
262   char *hexgrip;
263
264   if (pksk->timestamp > sig->timestamp )
265     {
266       ulong d = pksk->timestamp - sig->timestamp;
267       log_info (ngettext("key %s was created %lu second"
268                          " in the future (time warp or clock problem)\n",
269                          "key %s was created %lu seconds"
270                          " in the future (time warp or clock problem)\n",
271                          d), keystr_from_pk (pksk), d);
272       if (!opt.ignore_time_conflict)
273         return gpg_error (GPG_ERR_TIME_CONFLICT);
274     }
275
276   print_pubkey_algo_note (pksk->pubkey_algo);
277
278   if (!mdalgo)
279     mdalgo = gcry_md_get_algo (md);
280
281   /* Check compliance.  */
282   if (! gnupg_digest_is_allowed (opt.compliance, 1, mdalgo))
283     {
284       log_error (_("you may not use digest algorithm '%s'"
285                    " while 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 not suitable for signing while 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         PKT_public_key *pk;
591         PKT_onepass_sig *ops;
592         PACKET pkt;
593         int i, rc;
594
595         for (i=0, sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
596             if (++i == skcount)
597                 break;
598         }
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             log_error ("build onepass_sig packet failed: %s\n",
615                        gpg_strerror (rc));
616             return rc;
617         }
618     }
619
620     return 0;
621 }
622
623 /*
624  * Helper to write the plaintext (literal data) packet
625  */
626 static int
627 write_plaintext_packet (IOBUF out, IOBUF inp, const char *fname, int ptmode)
628 {
629     PKT_plaintext *pt = NULL;
630     u32 filesize;
631     int rc = 0;
632
633     if (!opt.no_literal)
634       pt=setup_plaintext_name(fname,inp);
635
636     /* try to calculate the length of the data */
637     if ( !iobuf_is_pipe_filename (fname) && *fname )
638       {
639         off_t tmpsize;
640         int overflow;
641
642         if( !(tmpsize = iobuf_get_filelength(inp, &overflow))
643             && !overflow && opt.verbose)
644           log_info (_("WARNING: '%s' is an empty file\n"), fname);
645
646         /* We can't encode the length of very large files because
647            OpenPGP uses only 32 bit for file sizes.  So if the size of
648            a file is larger than 2^32 minus some bytes for packet
649            headers, we switch to partial length encoding. */
650         if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
651           filesize = tmpsize;
652         else
653           filesize = 0;
654
655         /* Because the text_filter modifies the length of the
656          * data, it is not possible to know the used length
657          * without a double read of the file - to avoid that
658          * we simple use partial length packets. */
659         if ( ptmode == 't' || ptmode == 'u' || ptmode == 'm')
660           filesize = 0;
661       }
662     else
663       filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
664
665     if (!opt.no_literal) {
666         PACKET pkt;
667
668         /* Note that PT has been initialized above in no_literal mode.  */
669         pt->timestamp = make_timestamp ();
670         pt->mode = ptmode;
671         pt->len = filesize;
672         pt->new_ctb = !pt->len;
673         pt->buf = inp;
674         init_packet(&pkt);
675         pkt.pkttype = PKT_PLAINTEXT;
676         pkt.pkt.plaintext = pt;
677         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
678         if( (rc = build_packet (out, &pkt)) )
679             log_error ("build_packet(PLAINTEXT) failed: %s\n",
680                        gpg_strerror (rc) );
681         pt->buf = NULL;
682         free_packet (&pkt, NULL);
683     }
684     else {
685         byte copy_buffer[4096];
686         int  bytes_copied;
687
688         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
689             if ( (rc=iobuf_write(out, copy_buffer, bytes_copied)) ) {
690                 log_error ("copying input to output failed: %s\n",
691                            gpg_strerror (rc));
692                 break;
693             }
694         wipememory(copy_buffer,4096); /* burn buffer */
695     }
696     /* fixme: it seems that we never freed pt/pkt */
697
698     return rc;
699 }
700
701 /*
702  * Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
703  * hash which will not be changes here.
704  */
705 static int
706 write_signature_packets (ctrl_t ctrl,
707                          SK_LIST sk_list, IOBUF out, gcry_md_hd_t hash,
708                          int sigclass, u32 timestamp, u32 duration,
709                          int status_letter, const char *cache_nonce)
710 {
711   SK_LIST sk_rover;
712
713   /* Loop over the certificates with secret keys. */
714   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
715     {
716       PKT_public_key *pk;
717       PKT_signature *sig;
718       gcry_md_hd_t md;
719       int rc;
720
721       pk = sk_rover->pk;
722
723       /* Build the signature packet.  */
724       sig = xtrycalloc (1, sizeof *sig);
725       if (!sig)
726         return gpg_error_from_syserror ();
727
728       if (duration || opt.sig_policy_url
729           || opt.sig_notations || opt.sig_keyserver_url)
730         sig->version = 4;
731       else
732         sig->version = pk->version;
733
734       keyid_from_pk (pk, sig->keyid);
735       sig->digest_algo = hash_for (pk);
736       sig->pubkey_algo = pk->pubkey_algo;
737       if (timestamp)
738         sig->timestamp = timestamp;
739       else
740         sig->timestamp = make_timestamp();
741       if (duration)
742         sig->expiredate = sig->timestamp + duration;
743       sig->sig_class = sigclass;
744
745       if (gcry_md_copy (&md, hash))
746         BUG ();
747
748       if (sig->version >= 4)
749         {
750           build_sig_subpkt_from_sig (sig, pk);
751           mk_notation_policy_etc (sig, NULL, pk);
752         }
753
754       hash_sigversion_to_magic (md, sig);
755       gcry_md_final (md);
756
757       rc = do_sign (ctrl, pk, sig, md, hash_for (pk), cache_nonce);
758       gcry_md_close (md);
759       if (!rc)
760         {
761           /* Write the packet.  */
762           PACKET pkt;
763
764           init_packet (&pkt);
765           pkt.pkttype = PKT_SIGNATURE;
766           pkt.pkt.signature = sig;
767           rc = build_packet (out, &pkt);
768           if (!rc && is_status_enabled())
769             print_status_sig_created (pk, sig, status_letter);
770           free_packet (&pkt, NULL);
771           if (rc)
772             log_error ("build signature packet failed: %s\n",
773                        gpg_strerror (rc));
774         }
775       else
776         xfree (sig);
777
778       if (rc)
779         return rc;
780     }
781
782   return 0;
783 }
784
785
786 /****************
787  * Sign the files whose names are in FILENAME.
788  * If DETACHED has the value true,
789  * make a detached signature.  If FILENAMES->d is NULL read from stdin
790  * and ignore the detached mode.  Sign the file with all secret keys
791  * which can be taken from LOCUSR, if this is NULL, use the default one
792  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
793  * signed data for these users.
794  * If OUTFILE is not NULL; this file is used for output and the function
795  * does not ask for overwrite permission; output is then always
796  * uncompressed, non-armored and in binary mode.
797  */
798 int
799 sign_file (ctrl_t ctrl, strlist_t filenames, int detached, strlist_t locusr,
800            int encryptflag, strlist_t remusr, const char *outfile )
801 {
802     const char *fname;
803     armor_filter_context_t *afx;
804     compress_filter_context_t zfx;
805     md_filter_context_t mfx;
806     text_filter_context_t tfx;
807     progress_filter_context_t *pfx;
808     encrypt_filter_context_t efx;
809     IOBUF inp = NULL, out = NULL;
810     PACKET pkt;
811     int rc = 0;
812     PK_LIST pk_list = NULL;
813     SK_LIST sk_list = NULL;
814     SK_LIST sk_rover = NULL;
815     int multifile = 0;
816     u32 duration=0;
817
818     pfx = new_progress_context ();
819     afx = new_armor_context ();
820     memset( &zfx, 0, sizeof zfx);
821     memset( &mfx, 0, sizeof mfx);
822     memset( &efx, 0, sizeof efx);
823     efx.ctrl = ctrl;
824     init_packet( &pkt );
825
826     if( filenames ) {
827         fname = filenames->d;
828         multifile = !!filenames->next;
829     }
830     else
831         fname = NULL;
832
833     if( fname && filenames->next && (!detached || encryptflag) )
834         log_bug("multiple files can only be detached signed");
835
836     if(encryptflag==2
837        && (rc=setup_symkey(&efx.symkey_s2k,&efx.symkey_dek)))
838       goto leave;
839
840     if (opt.ask_sig_expire && !opt.batch)
841       duration = ask_expire_interval(1,opt.def_sig_expire);
842     else
843       duration = parse_expire_string(opt.def_sig_expire);
844
845     /* Note: In the old non-agent version the following call used to
846        unprotect the secret key.  This is now done on demand by the agent.  */
847     if( (rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_SIG )) )
848         goto leave;
849
850     if (encryptflag
851         && (rc=build_pk_list (ctrl, remusr, &pk_list)))
852       goto leave;
853
854     /* prepare iobufs */
855     if( multifile )  /* have list of filenames */
856         inp = NULL; /* we do it later */
857     else {
858       inp = iobuf_open(fname);
859       if (inp && is_secured_file (iobuf_get_fd (inp)))
860         {
861           iobuf_close (inp);
862           inp = NULL;
863           gpg_err_set_errno (EPERM);
864         }
865       if( !inp )
866         {
867           rc = gpg_error_from_syserror ();
868           log_error (_("can't open '%s': %s\n"), fname? fname: "[stdin]",
869                      strerror(errno) );
870           goto leave;
871         }
872
873         handle_progress (pfx, inp, fname);
874     }
875
876     if( outfile ) {
877         if (is_secured_filename ( outfile )) {
878             out = NULL;
879             gpg_err_set_errno (EPERM);
880         }
881         else
882           out = iobuf_create (outfile, 0);
883         if( !out )
884           {
885             rc = gpg_error_from_syserror ();
886             log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
887             goto leave;
888           }
889         else if( opt.verbose )
890             log_info(_("writing to '%s'\n"), outfile );
891     }
892     else if( (rc = open_outfile (-1, fname,
893                                  opt.armor? 1: detached? 2:0, 0, &out)))
894         goto leave;
895
896     /* prepare to calculate the MD over the input */
897     if( opt.textmode && !outfile && !multifile )
898       {
899         memset( &tfx, 0, sizeof tfx);
900         iobuf_push_filter( inp, text_filter, &tfx );
901       }
902
903     if ( gcry_md_open (&mfx.md, 0, 0) )
904       BUG ();
905     if (DBG_HASHING)
906       gcry_md_debug (mfx.md, "sign");
907
908     /* If we're encrypting and signing, it is reasonable to pick the
909        hash algorithm to use out of the recipient key prefs.  This is
910        best effort only, as in a DSA2 and smartcard world there are
911        cases where we cannot please everyone with a single hash (DSA2
912        wants >160 and smartcards want =160).  In the future this could
913        be more complex with different hashes for each sk, but the
914        current design requires a single hash for all SKs. */
915     if(pk_list)
916       {
917         if(opt.def_digest_algo)
918           {
919             if(!opt.expert &&
920                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
921                                       opt.def_digest_algo,
922                                       NULL)!=opt.def_digest_algo)
923           log_info(_("WARNING: forcing digest algorithm %s (%d)"
924                      " violates recipient preferences\n"),
925                    gcry_md_algo_name (opt.def_digest_algo),
926                    opt.def_digest_algo );
927           }
928         else
929           {
930             int algo, smartcard=0;
931             union pref_hint hint;
932
933             hint.digest_length = 0;
934
935             /* Of course, if the recipient asks for something
936                unreasonable (like the wrong hash for a DSA key) then
937                don't do it.  Check all sk's - if any are DSA or live
938                on a smartcard, then the hash has restrictions and we
939                may not be able to give the recipient what they want.
940                For DSA, pass a hint for the largest q we have.  Note
941                that this means that a q>160 key will override a q=160
942                key and force the use of truncation for the q=160 key.
943                The alternative would be to ignore the recipient prefs
944                completely and get a different hash for each DSA key in
945                hash_for().  The override behavior here is more or less
946                reasonable as it is under the control of the user which
947                keys they sign with for a given message and the fact
948                that the message with multiple signatures won't be
949                usable on an implementation that doesn't understand
950                DSA2 anyway. */
951
952             for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
953               {
954                 if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_DSA
955                     || sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
956                   {
957                     int temp_hashlen = (gcry_mpi_get_nbits
958                                         (sk_rover->pk->pkey[1]));
959
960                     if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
961                       temp_hashlen = ecdsa_qbits_from_Q (temp_hashlen);
962                     temp_hashlen = (temp_hashlen+7)/8;
963
964                     /* Pick a hash that is large enough for our
965                        largest q */
966
967                     if (hint.digest_length<temp_hashlen)
968                       hint.digest_length=temp_hashlen;
969                   }
970                 /* FIXME: need to check gpg-agent for this. */
971                 /* else if (sk_rover->pk->is_protected */
972                 /*          && sk_rover->pk->protect.s2k.mode == 1002) */
973                 /*   smartcard = 1;  */
974               }
975
976             /* Current smartcards only do 160-bit hashes.  If we have
977                to have a >160-bit hash, then we can't use the
978                recipient prefs as we'd need both =160 and >160 at the
979                same time and recipient prefs currently require a
980                single hash for all signatures.  All this may well have
981                to change as the cards add algorithms. */
982
983             if (!smartcard || (smartcard && hint.digest_length==20))
984               if ( (algo=
985                    select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint)) > 0)
986                 recipient_digest_algo=algo;
987           }
988       }
989
990     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
991       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
992
993     if( !multifile )
994         iobuf_push_filter( inp, md_filter, &mfx );
995
996     if( detached && !encryptflag)
997         afx->what = 2;
998
999     if( opt.armor && !outfile  )
1000         push_armor_filter (afx, out);
1001
1002     if( encryptflag ) {
1003         efx.pk_list = pk_list;
1004         /* fixme: set efx.cfx.datalen if known */
1005         iobuf_push_filter( out, encrypt_filter, &efx );
1006     }
1007
1008     if (opt.compress_algo && !outfile && !detached)
1009       {
1010         int compr_algo=opt.compress_algo;
1011
1012         /* If not forced by user */
1013         if(compr_algo==-1)
1014           {
1015             /* If we're not encrypting, then select_algo_from_prefs
1016                will fail and we'll end up with the default.  If we are
1017                encrypting, select_algo_from_prefs cannot fail since
1018                there is an assumed preference for uncompressed data.
1019                Still, if it did fail, we'll also end up with the
1020                default. */
1021
1022             if((compr_algo=
1023                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
1024               compr_algo=default_compress_algo();
1025           }
1026         else if(!opt.expert && pk_list
1027                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
1028                                           compr_algo,NULL)!=compr_algo)
1029           log_info(_("WARNING: forcing compression algorithm %s (%d)"
1030                      " violates recipient preferences\n"),
1031                    compress_algo_to_string(compr_algo),compr_algo);
1032
1033         /* algo 0 means no compression */
1034         if( compr_algo )
1035           push_compress_filter(out,&zfx,compr_algo);
1036       }
1037
1038     /* Write the one-pass signature packets if needed */
1039     if (!detached) {
1040         rc = write_onepass_sig_packets (sk_list, out,
1041                                         opt.textmode && !outfile ? 0x01:0x00);
1042         if (rc)
1043             goto leave;
1044     }
1045
1046     write_status_begin_signing (mfx.md);
1047
1048     /* Setup the inner packet. */
1049     if( detached ) {
1050         if( multifile ) {
1051             strlist_t sl;
1052
1053             if( opt.verbose )
1054                 log_info(_("signing:") );
1055             /* must walk reverse trough this list */
1056             for( sl = strlist_last(filenames); sl;
1057                         sl = strlist_prev( filenames, sl ) ) {
1058                 inp = iobuf_open(sl->d);
1059                 if (inp && is_secured_file (iobuf_get_fd (inp)))
1060                   {
1061                     iobuf_close (inp);
1062                     inp = NULL;
1063                     gpg_err_set_errno (EPERM);
1064                   }
1065                 if( !inp )
1066                   {
1067                     rc = gpg_error_from_syserror ();
1068                     log_error(_("can't open '%s': %s\n"),
1069                               sl->d,strerror(errno));
1070                     goto leave;
1071                   }
1072                 handle_progress (pfx, inp, sl->d);
1073                 if( opt.verbose )
1074                   log_printf (" '%s'", sl->d );
1075                 if(opt.textmode)
1076                   {
1077                     memset( &tfx, 0, sizeof tfx);
1078                     iobuf_push_filter( inp, text_filter, &tfx );
1079                   }
1080                 iobuf_push_filter( inp, md_filter, &mfx );
1081                 while( iobuf_get(inp) != -1 )
1082                     ;
1083                 iobuf_close(inp); inp = NULL;
1084             }
1085             if( opt.verbose )
1086               log_printf ("\n");
1087         }
1088         else {
1089             /* read, so that the filter can calculate the digest */
1090             while( iobuf_get(inp) != -1 )
1091                 ;
1092         }
1093     }
1094     else {
1095         rc = write_plaintext_packet (out, inp, fname,
1096                                      opt.textmode && !outfile ?
1097                                      (opt.mimemode? 'm':'t'):'b');
1098     }
1099
1100     /* catch errors from above */
1101     if (rc)
1102         goto leave;
1103
1104     /* write the signatures */
1105     rc = write_signature_packets (ctrl, sk_list, out, mfx.md,
1106                                   opt.textmode && !outfile? 0x01 : 0x00,
1107                                   0, duration, detached ? 'D':'S', NULL);
1108     if( rc )
1109         goto leave;
1110
1111
1112   leave:
1113     if( rc )
1114         iobuf_cancel(out);
1115     else {
1116         iobuf_close(out);
1117         if (encryptflag)
1118             write_status( STATUS_END_ENCRYPTION );
1119     }
1120     iobuf_close(inp);
1121     gcry_md_close ( mfx.md );
1122     release_sk_list( sk_list );
1123     release_pk_list( pk_list );
1124     recipient_digest_algo=0;
1125     release_progress_context (pfx);
1126     release_armor_context (afx);
1127     return rc;
1128 }
1129
1130
1131
1132 /****************
1133  * make a clear signature. note that opt.armor is not needed
1134  */
1135 int
1136 clearsign_file (ctrl_t ctrl,
1137                 const char *fname, strlist_t locusr, const char *outfile )
1138 {
1139     armor_filter_context_t *afx;
1140     progress_filter_context_t *pfx;
1141     gcry_md_hd_t textmd = NULL;
1142     IOBUF inp = NULL, out = NULL;
1143     PACKET pkt;
1144     int rc = 0;
1145     SK_LIST sk_list = NULL;
1146     SK_LIST sk_rover = NULL;
1147     u32 duration=0;
1148
1149     pfx = new_progress_context ();
1150     afx = new_armor_context ();
1151     init_packet( &pkt );
1152
1153     if (opt.ask_sig_expire && !opt.batch)
1154       duration = ask_expire_interval (1,opt.def_sig_expire);
1155     else
1156       duration = parse_expire_string (opt.def_sig_expire);
1157
1158     /* Note: In the old non-agent version the following call used to
1159        unprotect the secret key.  This is now done on demand by the agent.  */
1160     if( (rc=build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_SIG )) )
1161         goto leave;
1162
1163     /* prepare iobufs */
1164     inp = iobuf_open(fname);
1165     if (inp && is_secured_file (iobuf_get_fd (inp)))
1166       {
1167         iobuf_close (inp);
1168         inp = NULL;
1169         gpg_err_set_errno (EPERM);
1170       }
1171     if( !inp ) {
1172         rc = gpg_error_from_syserror ();
1173         log_error (_("can't open '%s': %s\n"),
1174                    fname? fname: "[stdin]", strerror(errno) );
1175         goto leave;
1176     }
1177     handle_progress (pfx, inp, fname);
1178
1179     if( outfile ) {
1180         if (is_secured_filename (outfile) ) {
1181             outfile = NULL;
1182             gpg_err_set_errno (EPERM);
1183         }
1184         else
1185           out = iobuf_create (outfile, 0);
1186         if( !out )
1187           {
1188             rc = gpg_error_from_syserror ();
1189             log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
1190             goto leave;
1191           }
1192         else if( opt.verbose )
1193             log_info(_("writing to '%s'\n"), outfile );
1194     }
1195     else if ((rc = open_outfile (-1, fname, 1, 0, &out)))
1196         goto leave;
1197
1198     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1199
1200     {
1201         const char *s;
1202         int any = 0;
1203         byte hashs_seen[256];
1204
1205         memset( hashs_seen, 0, sizeof hashs_seen );
1206         iobuf_writestr(out, "Hash: " );
1207         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1208             int i = hash_for (sk_rover->pk);
1209
1210             if( !hashs_seen[ i & 0xff ] ) {
1211                 s = gcry_md_algo_name ( i );
1212                 if( s ) {
1213                     hashs_seen[ i & 0xff ] = 1;
1214                     if( any )
1215                         iobuf_put(out, ',' );
1216                     iobuf_writestr(out, s );
1217                     any = 1;
1218                 }
1219             }
1220         }
1221         log_assert(any);
1222         iobuf_writestr(out, LF );
1223     }
1224
1225     if( opt.not_dash_escaped )
1226       iobuf_writestr( out,
1227                       "NotDashEscaped: You need "GPG_NAME
1228                       " to verify this message" LF );
1229     iobuf_writestr(out, LF );
1230
1231     if ( gcry_md_open (&textmd, 0, 0) )
1232       BUG ();
1233     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1234       gcry_md_enable (textmd, hash_for(sk_rover->pk));
1235
1236     if ( DBG_HASHING )
1237       gcry_md_debug ( textmd, "clearsign" );
1238
1239     copy_clearsig_text (out, inp, textmd, !opt.not_dash_escaped,
1240                         opt.escape_from);
1241     /* fixme: check for read errors */
1242
1243     /* now write the armor */
1244     afx->what = 2;
1245     push_armor_filter (afx, out);
1246
1247     /* Write the signatures.  */
1248     rc = write_signature_packets (ctrl, sk_list, out, textmd, 0x01, 0,
1249                                   duration, 'C', NULL);
1250     if( rc )
1251         goto leave;
1252
1253   leave:
1254     if( rc )
1255         iobuf_cancel(out);
1256     else
1257         iobuf_close(out);
1258     iobuf_close(inp);
1259     gcry_md_close ( textmd );
1260     release_sk_list( sk_list );
1261     release_progress_context (pfx);
1262     release_armor_context (afx);
1263     return rc;
1264 }
1265
1266 /*
1267  * Sign and conventionally encrypt the given file.
1268  * FIXME: Far too much code is duplicated - revamp the whole file.
1269  */
1270 int
1271 sign_symencrypt_file (ctrl_t ctrl, const char *fname, strlist_t locusr)
1272 {
1273     armor_filter_context_t *afx;
1274     progress_filter_context_t *pfx;
1275     compress_filter_context_t zfx;
1276     md_filter_context_t mfx;
1277     text_filter_context_t tfx;
1278     cipher_filter_context_t cfx;
1279     IOBUF inp = NULL, out = NULL;
1280     PACKET pkt;
1281     STRING2KEY *s2k = NULL;
1282     int rc = 0;
1283     SK_LIST sk_list = NULL;
1284     SK_LIST sk_rover = NULL;
1285     int algo;
1286     u32 duration=0;
1287     int canceled;
1288
1289     pfx = new_progress_context ();
1290     afx = new_armor_context ();
1291     memset( &zfx, 0, sizeof zfx);
1292     memset( &mfx, 0, sizeof mfx);
1293     memset( &tfx, 0, sizeof tfx);
1294     memset( &cfx, 0, sizeof cfx);
1295     init_packet( &pkt );
1296
1297     if (opt.ask_sig_expire && !opt.batch)
1298       duration = ask_expire_interval (1, opt.def_sig_expire);
1299     else
1300       duration = parse_expire_string (opt.def_sig_expire);
1301
1302     /* Note: In the old non-agent version the following call used to
1303        unprotect the secret key.  This is now done on demand by the agent.  */
1304     rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_SIG);
1305     if (rc)
1306         goto leave;
1307
1308     /* prepare iobufs */
1309     inp = iobuf_open(fname);
1310     if (inp && is_secured_file (iobuf_get_fd (inp)))
1311       {
1312         iobuf_close (inp);
1313         inp = NULL;
1314         gpg_err_set_errno (EPERM);
1315       }
1316     if( !inp ) {
1317         rc = gpg_error_from_syserror ();
1318         log_error (_("can't open '%s': %s\n"),
1319                    fname? fname: "[stdin]", strerror(errno) );
1320         goto leave;
1321     }
1322     handle_progress (pfx, inp, fname);
1323
1324     /* prepare key */
1325     s2k = xmalloc_clear( sizeof *s2k );
1326     s2k->mode = opt.s2k_mode;
1327     s2k->hash_algo = S2K_DIGEST_ALGO;
1328
1329     algo = default_cipher_algo();
1330     if (!opt.quiet || !opt.batch)
1331         log_info (_("%s encryption will be used\n"),
1332                   openpgp_cipher_algo_name (algo) );
1333     cfx.dek = passphrase_to_dek (algo, s2k, 1, 1, NULL, &canceled);
1334
1335     if (!cfx.dek || !cfx.dek->keylen) {
1336         rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
1337         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1338         goto leave;
1339     }
1340
1341     cfx.dek->use_mdc = use_mdc (NULL, cfx.dek->algo);
1342
1343     /* now create the outfile */
1344     rc = open_outfile (-1, fname, opt.armor? 1:0, 0, &out);
1345     if (rc)
1346         goto leave;
1347
1348     /* prepare to calculate the MD over the input */
1349     if (opt.textmode)
1350         iobuf_push_filter (inp, text_filter, &tfx);
1351     if ( gcry_md_open (&mfx.md, 0, 0) )
1352       BUG ();
1353     if ( DBG_HASHING )
1354       gcry_md_debug (mfx.md, "symc-sign");
1355
1356     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1357       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
1358
1359     iobuf_push_filter (inp, md_filter, &mfx);
1360
1361     /* Push armor output filter */
1362     if (opt.armor)
1363         push_armor_filter (afx, out);
1364
1365     /* Write the symmetric key packet */
1366     /*(current filters: armor)*/
1367     {
1368         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1369         enc->version = 4;
1370         enc->cipher_algo = cfx.dek->algo;
1371         enc->s2k = *s2k;
1372         pkt.pkttype = PKT_SYMKEY_ENC;
1373         pkt.pkt.symkey_enc = enc;
1374         if( (rc = build_packet( out, &pkt )) )
1375             log_error("build symkey packet failed: %s\n", gpg_strerror (rc) );
1376         xfree(enc);
1377     }
1378
1379     /* Push the encryption filter */
1380     iobuf_push_filter( out, cipher_filter, &cfx );
1381
1382     /* Push the compress filter */
1383     if (default_compress_algo())
1384       {
1385         if (cfx.dek && cfx.dek->use_mdc)
1386           zfx.new_ctb = 1;
1387         push_compress_filter (out, &zfx,default_compress_algo() );
1388       }
1389
1390     /* Write the one-pass signature packets */
1391     /*(current filters: zip - encrypt - armor)*/
1392     rc = write_onepass_sig_packets (sk_list, out,
1393                                     opt.textmode? 0x01:0x00);
1394     if (rc)
1395       goto leave;
1396
1397     write_status_begin_signing (mfx.md);
1398
1399     /* Pipe data through all filters; i.e. write the signed stuff */
1400     /*(current filters: zip - encrypt - armor)*/
1401     rc = write_plaintext_packet (out, inp, fname,
1402                                  opt.textmode ? (opt.mimemode?'m':'t'):'b');
1403     if (rc)
1404         goto leave;
1405
1406     /* Write the signatures */
1407     /*(current filters: zip - encrypt - armor)*/
1408     rc = write_signature_packets (ctrl, sk_list, out, mfx.md,
1409                                   opt.textmode? 0x01 : 0x00,
1410                                   0, duration, 'S', NULL);
1411     if( rc )
1412         goto leave;
1413
1414
1415   leave:
1416     if( rc )
1417         iobuf_cancel(out);
1418     else {
1419         iobuf_close(out);
1420         write_status( STATUS_END_ENCRYPTION );
1421     }
1422     iobuf_close(inp);
1423     release_sk_list( sk_list );
1424     gcry_md_close( mfx.md );
1425     xfree(cfx.dek);
1426     xfree(s2k);
1427     release_progress_context (pfx);
1428     release_armor_context (afx);
1429     return rc;
1430 }
1431
1432
1433 /****************
1434  * Create a v4 signature in *RET_SIG.
1435  *
1436  * PK is the primary key to sign (required for all sigs)
1437  * UID is the user id to sign (required for 0x10..0x13, 0x30)
1438  * SUBPK is subkey to sign (required for 0x18, 0x19, 0x28)
1439  *
1440  * PKSK is the signing key
1441  *
1442  * SIGCLASS is the type of signature to create.
1443  *
1444  * DIGEST_ALGO is the digest algorithm.  If it is 0 the function
1445  * selects an appropriate one.
1446  *
1447  * TIMESTAMP is the timestamp to use for the signature. 0 means "now"
1448  *
1449  * DURATION is the amount of time (in seconds) until the signature
1450  * expires.
1451  *
1452  * This function creates the following subpackets: issuer, created,
1453  * and expire (if duration is not 0).  Additional subpackets can be
1454  * added using MKSUBPKT, which is called after these subpackets are
1455  * added and before the signature is generated.  OPAQUE is passed to
1456  * MKSUBPKT.
1457  */
1458 int
1459 make_keysig_packet (ctrl_t ctrl,
1460                     PKT_signature **ret_sig, PKT_public_key *pk,
1461                     PKT_user_id *uid, PKT_public_key *subpk,
1462                     PKT_public_key *pksk,
1463                     int sigclass, int digest_algo,
1464                     u32 timestamp, u32 duration,
1465                     int (*mksubpkt)(PKT_signature *, void *), void *opaque,
1466                     const char *cache_nonce)
1467 {
1468     PKT_signature *sig;
1469     int rc=0;
1470     int sigversion;
1471     gcry_md_hd_t md;
1472
1473     log_assert ((sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1474                 || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1475                 || sigclass == 0x30 || sigclass == 0x28 );
1476
1477     sigversion = 4;
1478     if (sigversion < pksk->version)
1479         sigversion = pksk->version;
1480
1481     if( !digest_algo )
1482       {
1483         /* Basically, this means use SHA1 always unless the user
1484            specified something (use whatever they said), or it's DSA
1485            (use the best match).  They still can't pick an
1486            inappropriate hash for DSA or the signature will fail.
1487            Note that this still allows the caller of
1488            make_keysig_packet to override the user setting if it
1489            must. */
1490
1491         if(opt.cert_digest_algo)
1492           digest_algo=opt.cert_digest_algo;
1493         else if(pksk->pubkey_algo == PUBKEY_ALGO_DSA)
1494           digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
1495         else if (pksk->pubkey_algo == PUBKEY_ALGO_ECDSA
1496                  || pksk->pubkey_algo == PUBKEY_ALGO_EDDSA)
1497           {
1498             if (openpgp_oid_is_ed25519 (pksk->pkey[0]))
1499               digest_algo = DIGEST_ALGO_SHA256;
1500             else
1501               digest_algo = match_dsa_hash
1502                 (ecdsa_qbits_from_Q (gcry_mpi_get_nbits (pksk->pkey[1]))/8);
1503           }
1504         else
1505           digest_algo = DEFAULT_DIGEST_ALGO;
1506       }
1507
1508     if ( gcry_md_open (&md, digest_algo, 0 ) )
1509       BUG ();
1510
1511     /* Hash the public key certificate. */
1512     hash_public_key( md, pk );
1513
1514     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1515       {
1516         /* hash the subkey binding/backsig/revocation */
1517         hash_public_key( md, subpk );
1518       }
1519     else if( sigclass != 0x1F && sigclass != 0x20 )
1520       {
1521         /* hash the user id */
1522         hash_uid (md, sigversion, uid);
1523       }
1524     /* and make the signature packet */
1525     sig = xmalloc_clear( sizeof *sig );
1526     sig->version = sigversion;
1527     sig->flags.exportable=1;
1528     sig->flags.revocable=1;
1529     keyid_from_pk (pksk, sig->keyid);
1530     sig->pubkey_algo = pksk->pubkey_algo;
1531     sig->digest_algo = digest_algo;
1532     if(timestamp)
1533       sig->timestamp=timestamp;
1534     else
1535       sig->timestamp=make_timestamp();
1536     if(duration)
1537       sig->expiredate=sig->timestamp+duration;
1538     sig->sig_class = sigclass;
1539
1540     build_sig_subpkt_from_sig (sig, pksk);
1541     mk_notation_policy_etc (sig, pk, pksk);
1542
1543     /* Crucial that the call to mksubpkt comes LAST before the calls
1544        to finalize the sig as that makes it possible for the mksubpkt
1545        function to get a reliable pointer to the subpacket area. */
1546     if (mksubpkt)
1547         rc = (*mksubpkt)( sig, opaque );
1548
1549     if( !rc ) {
1550         hash_sigversion_to_magic (md, sig);
1551         gcry_md_final (md);
1552
1553         rc = complete_sig (ctrl, sig, pksk, md, cache_nonce);
1554     }
1555
1556     gcry_md_close (md);
1557     if( rc )
1558         free_seckey_enc( sig );
1559     else
1560         *ret_sig = sig;
1561     return rc;
1562 }
1563
1564
1565
1566 /****************
1567  * Create a new signature packet based on an existing one.
1568  * Only user ID signatures are supported for now.
1569  * PK is the public key to work on.
1570  * PKSK is the key used to make the signature.
1571  *
1572  * TODO: Merge this with make_keysig_packet.
1573  */
1574 gpg_error_t
1575 update_keysig_packet (ctrl_t ctrl,
1576                       PKT_signature **ret_sig,
1577                       PKT_signature *orig_sig,
1578                       PKT_public_key *pk,
1579                       PKT_user_id *uid,
1580                       PKT_public_key *subpk,
1581                       PKT_public_key *pksk,
1582                       int (*mksubpkt)(PKT_signature *, void *),
1583                       void *opaque)
1584 {
1585     PKT_signature *sig;
1586     gpg_error_t rc = 0;
1587     int digest_algo;
1588     gcry_md_hd_t md;
1589
1590     if ((!orig_sig || !pk || !pksk)
1591         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1592         || (orig_sig->sig_class == 0x18 && !subpk))
1593       return GPG_ERR_GENERAL;
1594
1595     if ( opt.cert_digest_algo )
1596       digest_algo = opt.cert_digest_algo;
1597     else
1598       digest_algo = orig_sig->digest_algo;
1599
1600     if ( gcry_md_open (&md, digest_algo, 0 ) )
1601       BUG ();
1602
1603     /* Hash the public key certificate and the user id. */
1604     hash_public_key( md, pk );
1605
1606     if( orig_sig->sig_class == 0x18 )
1607       hash_public_key( md, subpk );
1608     else
1609       hash_uid (md, orig_sig->version, uid);
1610
1611     /* create a new signature packet */
1612     sig = copy_signature (NULL, orig_sig);
1613
1614     sig->digest_algo=digest_algo;
1615
1616     /* We need to create a new timestamp so that new sig expiration
1617        calculations are done correctly... */
1618     sig->timestamp=make_timestamp();
1619
1620     /* ... but we won't make a timestamp earlier than the existing
1621        one. */
1622     {
1623       int tmout = 0;
1624       while(sig->timestamp<=orig_sig->timestamp)
1625         {
1626           if (++tmout > 5 && !opt.ignore_time_conflict)
1627             {
1628               rc = gpg_error (GPG_ERR_TIME_CONFLICT);
1629               goto leave;
1630             }
1631           gnupg_sleep (1);
1632           sig->timestamp=make_timestamp();
1633         }
1634     }
1635
1636     /* Note that already expired sigs will remain expired (with a
1637        duration of 1) since build-packet.c:build_sig_subpkt_from_sig
1638        detects this case. */
1639
1640     /* Put the updated timestamp into the sig.  Note that this will
1641        automagically lower any sig expiration dates to correctly
1642        correspond to the differences in the timestamps (i.e. the
1643        duration will shrink).  */
1644     build_sig_subpkt_from_sig (sig, pksk);
1645
1646     if (mksubpkt)
1647       rc = (*mksubpkt)(sig, opaque);
1648
1649     if (!rc) {
1650         hash_sigversion_to_magic (md, sig);
1651         gcry_md_final (md);
1652
1653         rc = complete_sig (ctrl, sig, pksk, md, NULL);
1654     }
1655
1656  leave:
1657     gcry_md_close (md);
1658     if( rc )
1659         free_seckey_enc (sig);
1660     else
1661         *ret_sig = sig;
1662     return rc;
1663 }