051ab594dc35bd7b0a18d397da6a0e8314ecc320
[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     if (!opt.quiet || !opt.batch)
1330         log_info (_("%s encryption will be used\n"),
1331                   openpgp_cipher_algo_name (algo) );
1332     cfx.dek = passphrase_to_dek (algo, s2k, 1, 1, NULL, &canceled);
1333
1334     if (!cfx.dek || !cfx.dek->keylen) {
1335         rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
1336         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1337         goto leave;
1338     }
1339
1340     if (use_aead (NULL, cfx.dek->algo))
1341       cfx.dek->use_aead = 1;
1342     else
1343       cfx.dek->use_mdc = !!use_mdc (NULL, cfx.dek->algo);
1344
1345     /* now create the outfile */
1346     rc = open_outfile (-1, fname, opt.armor? 1:0, 0, &out);
1347     if (rc)
1348         goto leave;
1349
1350     /* prepare to calculate the MD over the input */
1351     if (opt.textmode)
1352         iobuf_push_filter (inp, text_filter, &tfx);
1353     if ( gcry_md_open (&mfx.md, 0, 0) )
1354       BUG ();
1355     if ( DBG_HASHING )
1356       gcry_md_debug (mfx.md, "symc-sign");
1357
1358     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1359       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
1360
1361     iobuf_push_filter (inp, md_filter, &mfx);
1362
1363     /* Push armor output filter */
1364     if (opt.armor)
1365         push_armor_filter (afx, out);
1366
1367     /* Write the symmetric key packet */
1368     /*(current filters: armor)*/
1369     {
1370         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1371         enc->version = 4;
1372         enc->cipher_algo = cfx.dek->algo;
1373         enc->s2k = *s2k;
1374         pkt.pkttype = PKT_SYMKEY_ENC;
1375         pkt.pkt.symkey_enc = enc;
1376         if( (rc = build_packet( out, &pkt )) )
1377             log_error("build symkey packet failed: %s\n", gpg_strerror (rc) );
1378         xfree(enc);
1379     }
1380
1381     /* Push the encryption filter */
1382     iobuf_push_filter (out,
1383                        cfx.dek->use_aead? cipher_filter_aead
1384                        /**/             : cipher_filter_cfb,
1385                        &cfx);
1386
1387     /* Push the compress filter */
1388     if (default_compress_algo())
1389       {
1390         if (cfx.dek && (cfx.dek->use_mdc || cfx.dek->use_aead))
1391           zfx.new_ctb = 1;
1392         push_compress_filter (out, &zfx,default_compress_algo() );
1393       }
1394
1395     /* Write the one-pass signature packets */
1396     /*(current filters: zip - encrypt - armor)*/
1397     rc = write_onepass_sig_packets (sk_list, out,
1398                                     opt.textmode? 0x01:0x00);
1399     if (rc)
1400       goto leave;
1401
1402     write_status_begin_signing (mfx.md);
1403
1404     /* Pipe data through all filters; i.e. write the signed stuff */
1405     /*(current filters: zip - encrypt - armor)*/
1406     rc = write_plaintext_packet (out, inp, fname,
1407                                  opt.textmode ? (opt.mimemode?'m':'t'):'b');
1408     if (rc)
1409         goto leave;
1410
1411     /* Write the signatures */
1412     /*(current filters: zip - encrypt - armor)*/
1413     rc = write_signature_packets (ctrl, sk_list, out, mfx.md,
1414                                   opt.textmode? 0x01 : 0x00,
1415                                   0, duration, 'S', NULL);
1416     if( rc )
1417         goto leave;
1418
1419
1420   leave:
1421     if( rc )
1422         iobuf_cancel(out);
1423     else {
1424         iobuf_close(out);
1425         write_status( STATUS_END_ENCRYPTION );
1426     }
1427     iobuf_close(inp);
1428     release_sk_list( sk_list );
1429     gcry_md_close( mfx.md );
1430     xfree(cfx.dek);
1431     xfree(s2k);
1432     release_progress_context (pfx);
1433     release_armor_context (afx);
1434     return rc;
1435 }
1436
1437
1438 /****************
1439  * Create a v4 signature in *RET_SIG.
1440  *
1441  * PK is the primary key to sign (required for all sigs)
1442  * UID is the user id to sign (required for 0x10..0x13, 0x30)
1443  * SUBPK is subkey to sign (required for 0x18, 0x19, 0x28)
1444  *
1445  * PKSK is the signing key
1446  *
1447  * SIGCLASS is the type of signature to create.
1448  *
1449  * DIGEST_ALGO is the digest algorithm.  If it is 0 the function
1450  * selects an appropriate one.
1451  *
1452  * TIMESTAMP is the timestamp to use for the signature. 0 means "now"
1453  *
1454  * DURATION is the amount of time (in seconds) until the signature
1455  * expires.
1456  *
1457  * This function creates the following subpackets: issuer, created,
1458  * and expire (if duration is not 0).  Additional subpackets can be
1459  * added using MKSUBPKT, which is called after these subpackets are
1460  * added and before the signature is generated.  OPAQUE is passed to
1461  * MKSUBPKT.
1462  */
1463 int
1464 make_keysig_packet (ctrl_t ctrl,
1465                     PKT_signature **ret_sig, PKT_public_key *pk,
1466                     PKT_user_id *uid, PKT_public_key *subpk,
1467                     PKT_public_key *pksk,
1468                     int sigclass, int digest_algo,
1469                     u32 timestamp, u32 duration,
1470                     int (*mksubpkt)(PKT_signature *, void *), void *opaque,
1471                     const char *cache_nonce)
1472 {
1473     PKT_signature *sig;
1474     int rc=0;
1475     int sigversion;
1476     gcry_md_hd_t md;
1477
1478     log_assert ((sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1479                 || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1480                 || sigclass == 0x30 || sigclass == 0x28 );
1481
1482     sigversion = 4;
1483     if (sigversion < pksk->version)
1484         sigversion = pksk->version;
1485
1486     if( !digest_algo )
1487       {
1488         /* Basically, this means use SHA1 always unless the user
1489            specified something (use whatever they said), or it's DSA
1490            (use the best match).  They still can't pick an
1491            inappropriate hash for DSA or the signature will fail.
1492            Note that this still allows the caller of
1493            make_keysig_packet to override the user setting if it
1494            must. */
1495
1496         if(opt.cert_digest_algo)
1497           digest_algo=opt.cert_digest_algo;
1498         else if(pksk->pubkey_algo == PUBKEY_ALGO_DSA)
1499           digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
1500         else if (pksk->pubkey_algo == PUBKEY_ALGO_ECDSA
1501                  || pksk->pubkey_algo == PUBKEY_ALGO_EDDSA)
1502           {
1503             if (openpgp_oid_is_ed25519 (pksk->pkey[0]))
1504               digest_algo = DIGEST_ALGO_SHA256;
1505             else
1506               digest_algo = match_dsa_hash
1507                 (ecdsa_qbits_from_Q (gcry_mpi_get_nbits (pksk->pkey[1]))/8);
1508           }
1509         else
1510           digest_algo = DEFAULT_DIGEST_ALGO;
1511       }
1512
1513     if ( gcry_md_open (&md, digest_algo, 0 ) )
1514       BUG ();
1515
1516     /* Hash the public key certificate. */
1517     hash_public_key( md, pk );
1518
1519     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1520       {
1521         /* hash the subkey binding/backsig/revocation */
1522         hash_public_key( md, subpk );
1523       }
1524     else if( sigclass != 0x1F && sigclass != 0x20 )
1525       {
1526         /* hash the user id */
1527         hash_uid (md, sigversion, uid);
1528       }
1529     /* and make the signature packet */
1530     sig = xmalloc_clear( sizeof *sig );
1531     sig->version = sigversion;
1532     sig->flags.exportable=1;
1533     sig->flags.revocable=1;
1534     keyid_from_pk (pksk, sig->keyid);
1535     sig->pubkey_algo = pksk->pubkey_algo;
1536     sig->digest_algo = digest_algo;
1537     if(timestamp)
1538       sig->timestamp=timestamp;
1539     else
1540       sig->timestamp=make_timestamp();
1541     if(duration)
1542       sig->expiredate=sig->timestamp+duration;
1543     sig->sig_class = sigclass;
1544
1545     build_sig_subpkt_from_sig (sig, pksk);
1546     mk_notation_policy_etc (sig, pk, pksk);
1547
1548     /* Crucial that the call to mksubpkt comes LAST before the calls
1549        to finalize the sig as that makes it possible for the mksubpkt
1550        function to get a reliable pointer to the subpacket area. */
1551     if (mksubpkt)
1552         rc = (*mksubpkt)( sig, opaque );
1553
1554     if( !rc ) {
1555         hash_sigversion_to_magic (md, sig);
1556         gcry_md_final (md);
1557
1558         rc = complete_sig (ctrl, sig, pksk, md, cache_nonce);
1559     }
1560
1561     gcry_md_close (md);
1562     if( rc )
1563         free_seckey_enc( sig );
1564     else
1565         *ret_sig = sig;
1566     return rc;
1567 }
1568
1569
1570
1571 /****************
1572  * Create a new signature packet based on an existing one.
1573  * Only user ID signatures are supported for now.
1574  * PK is the public key to work on.
1575  * PKSK is the key used to make the signature.
1576  *
1577  * TODO: Merge this with make_keysig_packet.
1578  */
1579 gpg_error_t
1580 update_keysig_packet (ctrl_t ctrl,
1581                       PKT_signature **ret_sig,
1582                       PKT_signature *orig_sig,
1583                       PKT_public_key *pk,
1584                       PKT_user_id *uid,
1585                       PKT_public_key *subpk,
1586                       PKT_public_key *pksk,
1587                       int (*mksubpkt)(PKT_signature *, void *),
1588                       void *opaque)
1589 {
1590     PKT_signature *sig;
1591     gpg_error_t rc = 0;
1592     int digest_algo;
1593     gcry_md_hd_t md;
1594
1595     if ((!orig_sig || !pk || !pksk)
1596         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1597         || (orig_sig->sig_class == 0x18 && !subpk))
1598       return GPG_ERR_GENERAL;
1599
1600     if ( opt.cert_digest_algo )
1601       digest_algo = opt.cert_digest_algo;
1602     else
1603       digest_algo = orig_sig->digest_algo;
1604
1605     if ( gcry_md_open (&md, digest_algo, 0 ) )
1606       BUG ();
1607
1608     /* Hash the public key certificate and the user id. */
1609     hash_public_key( md, pk );
1610
1611     if( orig_sig->sig_class == 0x18 )
1612       hash_public_key( md, subpk );
1613     else
1614       hash_uid (md, orig_sig->version, uid);
1615
1616     /* create a new signature packet */
1617     sig = copy_signature (NULL, orig_sig);
1618
1619     sig->digest_algo=digest_algo;
1620
1621     /* We need to create a new timestamp so that new sig expiration
1622        calculations are done correctly... */
1623     sig->timestamp=make_timestamp();
1624
1625     /* ... but we won't make a timestamp earlier than the existing
1626        one. */
1627     {
1628       int tmout = 0;
1629       while(sig->timestamp<=orig_sig->timestamp)
1630         {
1631           if (++tmout > 5 && !opt.ignore_time_conflict)
1632             {
1633               rc = gpg_error (GPG_ERR_TIME_CONFLICT);
1634               goto leave;
1635             }
1636           gnupg_sleep (1);
1637           sig->timestamp=make_timestamp();
1638         }
1639     }
1640
1641     /* Note that already expired sigs will remain expired (with a
1642        duration of 1) since build-packet.c:build_sig_subpkt_from_sig
1643        detects this case. */
1644
1645     /* Put the updated timestamp into the sig.  Note that this will
1646        automagically lower any sig expiration dates to correctly
1647        correspond to the differences in the timestamps (i.e. the
1648        duration will shrink).  */
1649     build_sig_subpkt_from_sig (sig, pksk);
1650
1651     if (mksubpkt)
1652       rc = (*mksubpkt)(sig, opaque);
1653
1654     if (!rc) {
1655         hash_sigversion_to_magic (md, sig);
1656         gcry_md_final (md);
1657
1658         rc = complete_sig (ctrl, sig, pksk, md, NULL);
1659     }
1660
1661  leave:
1662     gcry_md_close (md);
1663     if( rc )
1664         free_seckey_enc (sig);
1665     else
1666         *ret_sig = sig;
1667     return rc;
1668 }