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