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