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