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