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