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