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