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