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