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