gpg: Write a status line for a failed --send-keys.
[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_ECDSA)
903                   {
904                     int temp_hashlen = (gcry_mpi_get_nbits
905                                         (sk_rover->pk->pkey[1]));
906
907                     if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
908                       temp_hashlen = ecdsa_qbits_from_Q (temp_hashlen);
909                     temp_hashlen = (temp_hashlen+7)/8;
910
911                     /* Pick a hash that is large enough for our
912                        largest q */
913
914                     if (hint.digest_length<temp_hashlen)
915                       hint.digest_length=temp_hashlen;
916                   }
917                 /* FIXME: need to check gpg-agent for this. */
918                 /* else if (sk_rover->pk->is_protected */
919                 /*          && sk_rover->pk->protect.s2k.mode == 1002) */
920                 /*   smartcard = 1;  */
921               }
922
923             /* Current smartcards only do 160-bit hashes.  If we have
924                to have a >160-bit hash, then we can't use the
925                recipient prefs as we'd need both =160 and >160 at the
926                same time and recipient prefs currently require a
927                single hash for all signatures.  All this may well have
928                to change as the cards add algorithms. */
929
930             if (!smartcard || (smartcard && hint.digest_length==20))
931               if ( (algo=
932                    select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint)) > 0)
933                 recipient_digest_algo=algo;
934           }
935       }
936
937     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
938       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
939
940     if( !multifile )
941         iobuf_push_filter( inp, md_filter, &mfx );
942
943     if( detached && !encryptflag)
944         afx->what = 2;
945
946     if( opt.armor && !outfile  )
947         push_armor_filter (afx, out);
948
949     if( encryptflag ) {
950         efx.pk_list = pk_list;
951         /* fixme: set efx.cfx.datalen if known */
952         iobuf_push_filter( out, encrypt_filter, &efx );
953     }
954
955     if (opt.compress_algo && !outfile && !detached)
956       {
957         int compr_algo=opt.compress_algo;
958
959         /* If not forced by user */
960         if(compr_algo==-1)
961           {
962             /* If we're not encrypting, then select_algo_from_prefs
963                will fail and we'll end up with the default.  If we are
964                encrypting, select_algo_from_prefs cannot fail since
965                there is an assumed preference for uncompressed data.
966                Still, if it did fail, we'll also end up with the
967                default. */
968
969             if((compr_algo=
970                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
971               compr_algo=default_compress_algo();
972           }
973         else if(!opt.expert && pk_list
974                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
975                                           compr_algo,NULL)!=compr_algo)
976           log_info(_("WARNING: forcing compression algorithm %s (%d)"
977                      " violates recipient preferences\n"),
978                    compress_algo_to_string(compr_algo),compr_algo);
979
980         /* algo 0 means no compression */
981         if( compr_algo )
982           push_compress_filter(out,&zfx,compr_algo);
983       }
984
985     /* Write the one-pass signature packets if needed */
986     if (!detached) {
987         rc = write_onepass_sig_packets (sk_list, out,
988                                         opt.textmode && !outfile ? 0x01:0x00);
989         if (rc)
990             goto leave;
991     }
992
993     write_status_begin_signing (mfx.md);
994
995     /* Setup the inner packet. */
996     if( detached ) {
997         if( multifile ) {
998             strlist_t sl;
999
1000             if( opt.verbose )
1001                 log_info(_("signing:") );
1002             /* must walk reverse trough this list */
1003             for( sl = strlist_last(filenames); sl;
1004                         sl = strlist_prev( filenames, sl ) ) {
1005                 inp = iobuf_open(sl->d);
1006                 if (inp && is_secured_file (iobuf_get_fd (inp)))
1007                   {
1008                     iobuf_close (inp);
1009                     inp = NULL;
1010                     gpg_err_set_errno (EPERM);
1011                   }
1012                 if( !inp )
1013                   {
1014                     rc = gpg_error_from_syserror ();
1015                     log_error(_("can't open '%s': %s\n"),
1016                               sl->d,strerror(errno));
1017                     goto leave;
1018                   }
1019                 handle_progress (pfx, inp, sl->d);
1020                 if( opt.verbose )
1021                     fprintf(stderr, " '%s'", sl->d );
1022                 if(opt.textmode)
1023                   {
1024                     memset( &tfx, 0, sizeof tfx);
1025                     iobuf_push_filter( inp, text_filter, &tfx );
1026                   }
1027                 iobuf_push_filter( inp, md_filter, &mfx );
1028                 while( iobuf_get(inp) != -1 )
1029                     ;
1030                 iobuf_close(inp); inp = NULL;
1031             }
1032             if( opt.verbose )
1033                 putc( '\n', stderr );
1034         }
1035         else {
1036             /* read, so that the filter can calculate the digest */
1037             while( iobuf_get(inp) != -1 )
1038                 ;
1039         }
1040     }
1041     else {
1042         rc = write_plaintext_packet (out, inp, fname,
1043                                      opt.textmode && !outfile ? 't':'b');
1044     }
1045
1046     /* catch errors from above */
1047     if (rc)
1048         goto leave;
1049
1050     /* write the signatures */
1051     rc = write_signature_packets (sk_list, out, mfx.md,
1052                                   opt.textmode && !outfile? 0x01 : 0x00,
1053                                   0, duration, detached ? 'D':'S', NULL);
1054     if( rc )
1055         goto leave;
1056
1057
1058   leave:
1059     if( rc )
1060         iobuf_cancel(out);
1061     else {
1062         iobuf_close(out);
1063         if (encryptflag)
1064             write_status( STATUS_END_ENCRYPTION );
1065     }
1066     iobuf_close(inp);
1067     gcry_md_close ( mfx.md );
1068     release_sk_list( sk_list );
1069     release_pk_list( pk_list );
1070     recipient_digest_algo=0;
1071     release_progress_context (pfx);
1072     release_armor_context (afx);
1073     return rc;
1074 }
1075
1076
1077
1078 /****************
1079  * make a clear signature. note that opt.armor is not needed
1080  */
1081 int
1082 clearsign_file( const char *fname, strlist_t locusr, const char *outfile )
1083 {
1084     armor_filter_context_t *afx;
1085     progress_filter_context_t *pfx;
1086     gcry_md_hd_t textmd = NULL;
1087     IOBUF inp = NULL, out = NULL;
1088     PACKET pkt;
1089     int rc = 0;
1090     SK_LIST sk_list = NULL;
1091     SK_LIST sk_rover = NULL;
1092     u32 duration=0;
1093
1094     pfx = new_progress_context ();
1095     afx = new_armor_context ();
1096     init_packet( &pkt );
1097
1098     if (opt.ask_sig_expire && !opt.batch)
1099       duration = ask_expire_interval (1,opt.def_sig_expire);
1100     else
1101       duration = parse_expire_string (opt.def_sig_expire);
1102
1103     /* Note: In the old non-agent version the following call used to
1104        unprotect the secret key.  This is now done on demand by the agent.  */
1105     if( (rc=build_sk_list( locusr, &sk_list, PUBKEY_USAGE_SIG )) )
1106         goto leave;
1107
1108     /* prepare iobufs */
1109     inp = iobuf_open(fname);
1110     if (inp && is_secured_file (iobuf_get_fd (inp)))
1111       {
1112         iobuf_close (inp);
1113         inp = NULL;
1114         gpg_err_set_errno (EPERM);
1115       }
1116     if( !inp ) {
1117         rc = gpg_error_from_syserror ();
1118         log_error (_("can't open '%s': %s\n"),
1119                    fname? fname: "[stdin]", strerror(errno) );
1120         goto leave;
1121     }
1122     handle_progress (pfx, inp, fname);
1123
1124     if( outfile ) {
1125         if (is_secured_filename (outfile) ) {
1126             outfile = NULL;
1127             gpg_err_set_errno (EPERM);
1128         }
1129         else
1130           out = iobuf_create (outfile, 0);
1131         if( !out )
1132           {
1133             rc = gpg_error_from_syserror ();
1134             log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
1135             goto leave;
1136           }
1137         else if( opt.verbose )
1138             log_info(_("writing to '%s'\n"), outfile );
1139     }
1140     else if ((rc = open_outfile (-1, fname, 1, 0, &out)))
1141         goto leave;
1142
1143     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1144
1145     {
1146         const char *s;
1147         int any = 0;
1148         byte hashs_seen[256];
1149
1150         memset( hashs_seen, 0, sizeof hashs_seen );
1151         iobuf_writestr(out, "Hash: " );
1152         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1153             int i = hash_for (sk_rover->pk);
1154
1155             if( !hashs_seen[ i & 0xff ] ) {
1156                 s = gcry_md_algo_name ( i );
1157                 if( s ) {
1158                     hashs_seen[ i & 0xff ] = 1;
1159                     if( any )
1160                         iobuf_put(out, ',' );
1161                     iobuf_writestr(out, s );
1162                     any = 1;
1163                 }
1164             }
1165         }
1166         assert(any);
1167         iobuf_writestr(out, LF );
1168     }
1169
1170     if( opt.not_dash_escaped )
1171       iobuf_writestr( out,
1172                       "NotDashEscaped: You need "GPG_NAME
1173                       " to verify this message" LF );
1174     iobuf_writestr(out, LF );
1175
1176     if ( gcry_md_open (&textmd, 0, 0) )
1177       BUG ();
1178     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1179       gcry_md_enable (textmd, hash_for(sk_rover->pk));
1180
1181     if ( DBG_HASHING )
1182       gcry_md_debug ( textmd, "clearsign" );
1183
1184     copy_clearsig_text (out, inp, textmd, !opt.not_dash_escaped,
1185                         opt.escape_from);
1186     /* fixme: check for read errors */
1187
1188     /* now write the armor */
1189     afx->what = 2;
1190     push_armor_filter (afx, out);
1191
1192     /* Write the signatures.  */
1193     rc = write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C',
1194                                   NULL);
1195     if( rc )
1196         goto leave;
1197
1198   leave:
1199     if( rc )
1200         iobuf_cancel(out);
1201     else
1202         iobuf_close(out);
1203     iobuf_close(inp);
1204     gcry_md_close ( textmd );
1205     release_sk_list( sk_list );
1206     release_progress_context (pfx);
1207     release_armor_context (afx);
1208     return rc;
1209 }
1210
1211 /*
1212  * Sign and conventionally encrypt the given file.
1213  * FIXME: Far too much code is duplicated - revamp the whole file.
1214  */
1215 int
1216 sign_symencrypt_file (const char *fname, strlist_t locusr)
1217 {
1218     armor_filter_context_t *afx;
1219     progress_filter_context_t *pfx;
1220     compress_filter_context_t zfx;
1221     md_filter_context_t mfx;
1222     text_filter_context_t tfx;
1223     cipher_filter_context_t cfx;
1224     IOBUF inp = NULL, out = NULL;
1225     PACKET pkt;
1226     STRING2KEY *s2k = NULL;
1227     int rc = 0;
1228     SK_LIST sk_list = NULL;
1229     SK_LIST sk_rover = NULL;
1230     int algo;
1231     u32 duration=0;
1232     int canceled;
1233
1234     pfx = new_progress_context ();
1235     afx = new_armor_context ();
1236     memset( &zfx, 0, sizeof zfx);
1237     memset( &mfx, 0, sizeof mfx);
1238     memset( &tfx, 0, sizeof tfx);
1239     memset( &cfx, 0, sizeof cfx);
1240     init_packet( &pkt );
1241
1242     if (opt.ask_sig_expire && !opt.batch)
1243       duration = ask_expire_interval (1, opt.def_sig_expire);
1244     else
1245       duration = parse_expire_string (opt.def_sig_expire);
1246
1247     /* Note: In the old non-agent version the following call used to
1248        unprotect the secret key.  This is now done on demand by the agent.  */
1249     rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG);
1250     if (rc)
1251         goto leave;
1252
1253     /* prepare iobufs */
1254     inp = iobuf_open(fname);
1255     if (inp && is_secured_file (iobuf_get_fd (inp)))
1256       {
1257         iobuf_close (inp);
1258         inp = NULL;
1259         gpg_err_set_errno (EPERM);
1260       }
1261     if( !inp ) {
1262         rc = gpg_error_from_syserror ();
1263         log_error (_("can't open '%s': %s\n"),
1264                    fname? fname: "[stdin]", strerror(errno) );
1265         goto leave;
1266     }
1267     handle_progress (pfx, inp, fname);
1268
1269     /* prepare key */
1270     s2k = xmalloc_clear( sizeof *s2k );
1271     s2k->mode = opt.s2k_mode;
1272     s2k->hash_algo = S2K_DIGEST_ALGO;
1273
1274     algo = default_cipher_algo();
1275     if (!opt.quiet || !opt.batch)
1276         log_info (_("%s encryption will be used\n"),
1277                   openpgp_cipher_algo_name (algo) );
1278     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, &canceled);
1279
1280     if (!cfx.dek || !cfx.dek->keylen) {
1281         rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
1282         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1283         goto leave;
1284     }
1285
1286     /* We have no way to tell if the recipient can handle messages
1287        with an MDC, so this defaults to no.  Perhaps in a few years,
1288        this can be defaulted to yes.  Note that like regular
1289        encrypting, --force-mdc overrides --disable-mdc. */
1290     if(opt.force_mdc)
1291       cfx.dek->use_mdc=1;
1292
1293     /* now create the outfile */
1294     rc = open_outfile (-1, fname, opt.armor? 1:0, 0, &out);
1295     if (rc)
1296         goto leave;
1297
1298     /* prepare to calculate the MD over the input */
1299     if (opt.textmode)
1300         iobuf_push_filter (inp, text_filter, &tfx);
1301     if ( gcry_md_open (&mfx.md, 0, 0) )
1302       BUG ();
1303     if ( DBG_HASHING )
1304       gcry_md_debug (mfx.md, "symc-sign");
1305
1306     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1307       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
1308
1309     iobuf_push_filter (inp, md_filter, &mfx);
1310
1311     /* Push armor output filter */
1312     if (opt.armor)
1313         push_armor_filter (afx, out);
1314
1315     /* Write the symmetric key packet */
1316     /*(current filters: armor)*/
1317     {
1318         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1319         enc->version = 4;
1320         enc->cipher_algo = cfx.dek->algo;
1321         enc->s2k = *s2k;
1322         pkt.pkttype = PKT_SYMKEY_ENC;
1323         pkt.pkt.symkey_enc = enc;
1324         if( (rc = build_packet( out, &pkt )) )
1325             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1326         xfree(enc);
1327     }
1328
1329     /* Push the encryption filter */
1330     iobuf_push_filter( out, cipher_filter, &cfx );
1331
1332     /* Push the compress filter */
1333     if (default_compress_algo())
1334       push_compress_filter(out,&zfx,default_compress_algo());
1335
1336     /* Write the one-pass signature packets */
1337     /*(current filters: zip - encrypt - armor)*/
1338     rc = write_onepass_sig_packets (sk_list, out,
1339                                     opt.textmode? 0x01:0x00);
1340     if (rc)
1341       goto leave;
1342
1343     write_status_begin_signing (mfx.md);
1344
1345     /* Pipe data through all filters; i.e. write the signed stuff */
1346     /*(current filters: zip - encrypt - armor)*/
1347     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1348     if (rc)
1349         goto leave;
1350
1351     /* Write the signatures */
1352     /*(current filters: zip - encrypt - armor)*/
1353     rc = write_signature_packets (sk_list, out, mfx.md,
1354                                   opt.textmode? 0x01 : 0x00,
1355                                   0, duration, 'S', NULL);
1356     if( rc )
1357         goto leave;
1358
1359
1360   leave:
1361     if( rc )
1362         iobuf_cancel(out);
1363     else {
1364         iobuf_close(out);
1365         write_status( STATUS_END_ENCRYPTION );
1366     }
1367     iobuf_close(inp);
1368     release_sk_list( sk_list );
1369     gcry_md_close( mfx.md );
1370     xfree(cfx.dek);
1371     xfree(s2k);
1372     release_progress_context (pfx);
1373     release_armor_context (afx);
1374     return rc;
1375 }
1376
1377
1378 /****************
1379  * Create a signature packet for the given public key certificate and
1380  * the user id and return it in ret_sig. User signature class SIGCLASS
1381  * user-id is not used (and may be NULL if sigclass is 0x20) If
1382  * DIGEST_ALGO is 0 the function selects an appropriate one.
1383  * SIGVERSION gives the minimal required signature packet version;
1384  * this is needed so that special properties like local sign are not
1385  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1386  * the timestamp to use for the signature. 0 means "now" */
1387 int
1388 make_keysig_packet (PKT_signature **ret_sig, PKT_public_key *pk,
1389                     PKT_user_id *uid, PKT_public_key *subpk,
1390                     PKT_public_key *pksk,
1391                     int sigclass, int digest_algo,
1392                     u32 timestamp, u32 duration,
1393                     int (*mksubpkt)(PKT_signature *, void *), void *opaque,
1394                     const char *cache_nonce)
1395 {
1396     PKT_signature *sig;
1397     int rc=0;
1398     int sigversion;
1399     gcry_md_hd_t md;
1400
1401     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1402             || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1403             || sigclass == 0x30 || sigclass == 0x28 );
1404
1405     sigversion = 4;
1406     if (sigversion < pksk->version)
1407         sigversion = pksk->version;
1408
1409     if( !digest_algo )
1410       {
1411         /* Basically, this means use SHA1 always unless the user
1412            specified something (use whatever they said), or it's DSA
1413            (use the best match).  They still can't pick an
1414            inappropriate hash for DSA or the signature will fail.
1415            Note that this still allows the caller of
1416            make_keysig_packet to override the user setting if it
1417            must. */
1418
1419         if(opt.cert_digest_algo)
1420           digest_algo=opt.cert_digest_algo;
1421         else if(pksk->pubkey_algo == PUBKEY_ALGO_DSA)
1422           digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
1423         else if (pksk->pubkey_algo == PUBKEY_ALGO_ECDSA
1424                  || pksk->pubkey_algo == PUBKEY_ALGO_EDDSA)
1425           {
1426             if (openpgp_oid_is_ed25519 (pksk->pkey[0]))
1427               digest_algo = DIGEST_ALGO_SHA256;
1428             else
1429               digest_algo = match_dsa_hash
1430                 (ecdsa_qbits_from_Q (gcry_mpi_get_nbits (pksk->pkey[1]))/8);
1431           }
1432         else
1433           digest_algo = DEFAULT_DIGEST_ALGO;
1434       }
1435
1436     if ( gcry_md_open (&md, digest_algo, 0 ) )
1437       BUG ();
1438
1439     /* Hash the public key certificate. */
1440     hash_public_key( md, pk );
1441
1442     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1443       {
1444         /* hash the subkey binding/backsig/revocation */
1445         hash_public_key( md, subpk );
1446       }
1447     else if( sigclass != 0x1F && sigclass != 0x20 )
1448       {
1449         /* hash the user id */
1450         hash_uid (md, sigversion, uid);
1451       }
1452     /* and make the signature packet */
1453     sig = xmalloc_clear( sizeof *sig );
1454     sig->version = sigversion;
1455     sig->flags.exportable=1;
1456     sig->flags.revocable=1;
1457     keyid_from_pk (pksk, sig->keyid);
1458     sig->pubkey_algo = pksk->pubkey_algo;
1459     sig->digest_algo = digest_algo;
1460     if(timestamp)
1461       sig->timestamp=timestamp;
1462     else
1463       sig->timestamp=make_timestamp();
1464     if(duration)
1465       sig->expiredate=sig->timestamp+duration;
1466     sig->sig_class = sigclass;
1467
1468     build_sig_subpkt_from_sig( sig );
1469     mk_notation_policy_etc (sig, pk, pksk);
1470
1471     /* Crucial that the call to mksubpkt comes LAST before the calls
1472        to finalize the sig as that makes it possible for the mksubpkt
1473        function to get a reliable pointer to the subpacket area. */
1474     if (mksubpkt)
1475         rc = (*mksubpkt)( sig, opaque );
1476
1477     if( !rc ) {
1478         hash_sigversion_to_magic (md, sig);
1479         gcry_md_final (md);
1480
1481         rc = complete_sig (sig, pksk, md, cache_nonce);
1482     }
1483
1484     gcry_md_close (md);
1485     if( rc )
1486         free_seckey_enc( sig );
1487     else
1488         *ret_sig = sig;
1489     return rc;
1490 }
1491
1492
1493
1494 /****************
1495  * Create a new signature packet based on an existing one.
1496  * Only user ID signatures are supported for now.
1497  * PK is the public key to work on.
1498  * PKSK is the key used to make the signature.
1499  *
1500  * TODO: Merge this with make_keysig_packet.
1501  */
1502 int
1503 update_keysig_packet( PKT_signature **ret_sig,
1504                       PKT_signature *orig_sig,
1505                       PKT_public_key *pk,
1506                       PKT_user_id *uid,
1507                       PKT_public_key *subpk,
1508                       PKT_public_key *pksk,
1509                       int (*mksubpkt)(PKT_signature *, void *),
1510                       void *opaque)
1511 {
1512     PKT_signature *sig;
1513     int rc = 0;
1514     int digest_algo;
1515     gcry_md_hd_t md;
1516
1517     if ((!orig_sig || !pk || !pksk)
1518         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1519         || (orig_sig->sig_class == 0x18 && !subpk))
1520       return G10ERR_GENERAL;
1521
1522     if ( opt.cert_digest_algo )
1523       digest_algo = opt.cert_digest_algo;
1524     else
1525       digest_algo = orig_sig->digest_algo;
1526
1527     if ( gcry_md_open (&md, digest_algo, 0 ) )
1528       BUG ();
1529
1530     /* Hash the public key certificate and the user id. */
1531     hash_public_key( md, pk );
1532
1533     if( orig_sig->sig_class == 0x18 )
1534       hash_public_key( md, subpk );
1535     else
1536       hash_uid (md, orig_sig->version, uid);
1537
1538     /* create a new signature packet */
1539     sig = copy_signature (NULL, orig_sig);
1540
1541     sig->digest_algo=digest_algo;
1542
1543     /* We need to create a new timestamp so that new sig expiration
1544        calculations are done correctly... */
1545     sig->timestamp=make_timestamp();
1546
1547     /* ... but we won't make a timestamp earlier than the existing
1548        one. */
1549     while(sig->timestamp<=orig_sig->timestamp)
1550       {
1551         gnupg_sleep (1);
1552         sig->timestamp=make_timestamp();
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 );
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     gcry_md_close (md);
1576     if( rc )
1577         free_seckey_enc (sig);
1578     else
1579         *ret_sig = sig;
1580     return rc;
1581 }