g10: fix cmp_public_key.
[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                    gpg_strerror (err));
316       free_public_key (pk);
317     }
318
319   if (err)
320     log_error (_("signing failed: %s\n"), gpg_strerror (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                        gpg_strerror (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                        gpg_strerror (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       if (sig->version >= 4)
704         {
705           build_sig_subpkt_from_sig (sig);
706           mk_notation_policy_etc (sig, NULL, pk);
707         }
708
709       hash_sigversion_to_magic (md, sig);
710       gcry_md_final (md);
711
712       rc = do_sign (pk, sig, md, hash_for (pk), cache_nonce);
713       gcry_md_close (md);
714       if (!rc)
715         {
716           /* Write the packet.  */
717           PACKET pkt;
718
719           init_packet (&pkt);
720           pkt.pkttype = PKT_SIGNATURE;
721           pkt.pkt.signature = sig;
722           rc = build_packet (out, &pkt);
723           if (!rc && is_status_enabled())
724             print_status_sig_created (pk, sig, status_letter);
725           free_packet (&pkt);
726           if (rc)
727             log_error ("build signature packet failed: %s\n", gpg_strerror (rc));
728         }
729       if (rc)
730         return rc;
731     }
732
733   return 0;
734 }
735
736
737 /****************
738  * Sign the files whose names are in FILENAME.
739  * If DETACHED has the value true,
740  * make a detached signature.  If FILENAMES->d is NULL read from stdin
741  * and ignore the detached mode.  Sign the file with all secret keys
742  * which can be taken from LOCUSR, if this is NULL, use the default one
743  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
744  * signed data for these users.
745  * If OUTFILE is not NULL; this file is used for output and the function
746  * does not ask for overwrite permission; output is then always
747  * uncompressed, non-armored and in binary mode.
748  */
749 int
750 sign_file (ctrl_t ctrl, strlist_t filenames, int detached, strlist_t locusr,
751            int encryptflag, strlist_t remusr, const char *outfile )
752 {
753     const char *fname;
754     armor_filter_context_t *afx;
755     compress_filter_context_t zfx;
756     md_filter_context_t mfx;
757     text_filter_context_t tfx;
758     progress_filter_context_t *pfx;
759     encrypt_filter_context_t efx;
760     IOBUF inp = NULL, out = NULL;
761     PACKET pkt;
762     int rc = 0;
763     PK_LIST pk_list = NULL;
764     SK_LIST sk_list = NULL;
765     SK_LIST sk_rover = NULL;
766     int multifile = 0;
767     u32 duration=0;
768
769     pfx = new_progress_context ();
770     afx = new_armor_context ();
771     memset( &zfx, 0, sizeof zfx);
772     memset( &mfx, 0, sizeof mfx);
773     memset( &efx, 0, sizeof efx);
774     init_packet( &pkt );
775
776     if( filenames ) {
777         fname = filenames->d;
778         multifile = !!filenames->next;
779     }
780     else
781         fname = NULL;
782
783     if( fname && filenames->next && (!detached || encryptflag) )
784         log_bug("multiple files can only be detached signed");
785
786     if(encryptflag==2
787        && (rc=setup_symkey(&efx.symkey_s2k,&efx.symkey_dek)))
788       goto leave;
789
790     if (opt.ask_sig_expire && !opt.batch)
791       duration = ask_expire_interval(1,opt.def_sig_expire);
792     else
793       duration = parse_expire_string(opt.def_sig_expire);
794
795     /* Note: In the old non-agent version the following call used to
796        unprotect the secret key.  This is now done on demand by the agent.  */
797     if( (rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG )) )
798         goto leave;
799
800     if (encryptflag
801         && (rc=build_pk_list (ctrl, remusr, &pk_list, PUBKEY_USAGE_ENC)))
802       goto leave;
803
804     /* prepare iobufs */
805     if( multifile )  /* have list of filenames */
806         inp = NULL; /* we do it later */
807     else {
808       inp = iobuf_open(fname);
809       if (inp && is_secured_file (iobuf_get_fd (inp)))
810         {
811           iobuf_close (inp);
812           inp = NULL;
813           gpg_err_set_errno (EPERM);
814         }
815       if( !inp )
816         {
817           rc = gpg_error_from_syserror ();
818           log_error (_("can't open '%s': %s\n"), fname? fname: "[stdin]",
819                      strerror(errno) );
820           goto leave;
821         }
822
823         handle_progress (pfx, inp, fname);
824     }
825
826     if( outfile ) {
827         if (is_secured_filename ( outfile )) {
828             out = NULL;
829             gpg_err_set_errno (EPERM);
830         }
831         else
832           out = iobuf_create (outfile, 0);
833         if( !out )
834           {
835             rc = gpg_error_from_syserror ();
836             log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
837             goto leave;
838           }
839         else if( opt.verbose )
840             log_info(_("writing to '%s'\n"), outfile );
841     }
842     else if( (rc = open_outfile (-1, fname,
843                                  opt.armor? 1: detached? 2:0, 0, &out)))
844         goto leave;
845
846     /* prepare to calculate the MD over the input */
847     if( opt.textmode && !outfile && !multifile )
848       {
849         memset( &tfx, 0, sizeof tfx);
850         iobuf_push_filter( inp, text_filter, &tfx );
851       }
852
853     if ( gcry_md_open (&mfx.md, 0, 0) )
854       BUG ();
855     if (DBG_HASHING)
856       gcry_md_debug (mfx.md, "sign");
857
858     /* If we're encrypting and signing, it is reasonable to pick the
859        hash algorithm to use out of the recipient key prefs.  This is
860        best effort only, as in a DSA2 and smartcard world there are
861        cases where we cannot please everyone with a single hash (DSA2
862        wants >160 and smartcards want =160).  In the future this could
863        be more complex with different hashes for each sk, but the
864        current design requires a single hash for all SKs. */
865     if(pk_list)
866       {
867         if(opt.def_digest_algo)
868           {
869             if(!opt.expert &&
870                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
871                                       opt.def_digest_algo,
872                                       NULL)!=opt.def_digest_algo)
873           log_info(_("WARNING: forcing digest algorithm %s (%d)"
874                      " violates recipient preferences\n"),
875                    gcry_md_algo_name (opt.def_digest_algo),
876                    opt.def_digest_algo );
877           }
878         else
879           {
880             int algo, smartcard=0;
881             union pref_hint hint;
882
883             hint.digest_length = 0;
884
885             /* Of course, if the recipient asks for something
886                unreasonable (like the wrong hash for a DSA key) then
887                don't do it.  Check all sk's - if any are DSA or live
888                on a smartcard, then the hash has restrictions and we
889                may not be able to give the recipient what they want.
890                For DSA, pass a hint for the largest q we have.  Note
891                that this means that a q>160 key will override a q=160
892                key and force the use of truncation for the q=160 key.
893                The alternative would be to ignore the recipient prefs
894                completely and get a different hash for each DSA key in
895                hash_for().  The override behavior here is more or less
896                reasonable as it is under the control of the user which
897                keys they sign with for a given message and the fact
898                that the message with multiple signatures won't be
899                usable on an implementation that doesn't understand
900                DSA2 anyway. */
901
902             for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
903               {
904                 if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_DSA
905                     || sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
906                   {
907                     int temp_hashlen = (gcry_mpi_get_nbits
908                                         (sk_rover->pk->pkey[1]));
909
910                     if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
911                       temp_hashlen = ecdsa_qbits_from_Q (temp_hashlen);
912                     temp_hashlen = (temp_hashlen+7)/8;
913
914                     /* Pick a hash that is large enough for our
915                        largest q */
916
917                     if (hint.digest_length<temp_hashlen)
918                       hint.digest_length=temp_hashlen;
919                   }
920                 /* FIXME: need to check gpg-agent for this. */
921                 /* else if (sk_rover->pk->is_protected */
922                 /*          && sk_rover->pk->protect.s2k.mode == 1002) */
923                 /*   smartcard = 1;  */
924               }
925
926             /* Current smartcards only do 160-bit hashes.  If we have
927                to have a >160-bit hash, then we can't use the
928                recipient prefs as we'd need both =160 and >160 at the
929                same time and recipient prefs currently require a
930                single hash for all signatures.  All this may well have
931                to change as the cards add algorithms. */
932
933             if (!smartcard || (smartcard && hint.digest_length==20))
934               if ( (algo=
935                    select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint)) > 0)
936                 recipient_digest_algo=algo;
937           }
938       }
939
940     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
941       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
942
943     if( !multifile )
944         iobuf_push_filter( inp, md_filter, &mfx );
945
946     if( detached && !encryptflag)
947         afx->what = 2;
948
949     if( opt.armor && !outfile  )
950         push_armor_filter (afx, out);
951
952     if( encryptflag ) {
953         efx.pk_list = pk_list;
954         /* fixme: set efx.cfx.datalen if known */
955         iobuf_push_filter( out, encrypt_filter, &efx );
956     }
957
958     if (opt.compress_algo && !outfile && !detached)
959       {
960         int compr_algo=opt.compress_algo;
961
962         /* If not forced by user */
963         if(compr_algo==-1)
964           {
965             /* If we're not encrypting, then select_algo_from_prefs
966                will fail and we'll end up with the default.  If we are
967                encrypting, select_algo_from_prefs cannot fail since
968                there is an assumed preference for uncompressed data.
969                Still, if it did fail, we'll also end up with the
970                default. */
971
972             if((compr_algo=
973                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
974               compr_algo=default_compress_algo();
975           }
976         else if(!opt.expert && pk_list
977                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
978                                           compr_algo,NULL)!=compr_algo)
979           log_info(_("WARNING: forcing compression algorithm %s (%d)"
980                      " violates recipient preferences\n"),
981                    compress_algo_to_string(compr_algo),compr_algo);
982
983         /* algo 0 means no compression */
984         if( compr_algo )
985           push_compress_filter(out,&zfx,compr_algo);
986       }
987
988     /* Write the one-pass signature packets if needed */
989     if (!detached) {
990         rc = write_onepass_sig_packets (sk_list, out,
991                                         opt.textmode && !outfile ? 0x01:0x00);
992         if (rc)
993             goto leave;
994     }
995
996     write_status_begin_signing (mfx.md);
997
998     /* Setup the inner packet. */
999     if( detached ) {
1000         if( multifile ) {
1001             strlist_t sl;
1002
1003             if( opt.verbose )
1004                 log_info(_("signing:") );
1005             /* must walk reverse trough this list */
1006             for( sl = strlist_last(filenames); sl;
1007                         sl = strlist_prev( filenames, sl ) ) {
1008                 inp = iobuf_open(sl->d);
1009                 if (inp && is_secured_file (iobuf_get_fd (inp)))
1010                   {
1011                     iobuf_close (inp);
1012                     inp = NULL;
1013                     gpg_err_set_errno (EPERM);
1014                   }
1015                 if( !inp )
1016                   {
1017                     rc = gpg_error_from_syserror ();
1018                     log_error(_("can't open '%s': %s\n"),
1019                               sl->d,strerror(errno));
1020                     goto leave;
1021                   }
1022                 handle_progress (pfx, inp, sl->d);
1023                 if( opt.verbose )
1024                   log_printf (" '%s'", sl->d );
1025                 if(opt.textmode)
1026                   {
1027                     memset( &tfx, 0, sizeof tfx);
1028                     iobuf_push_filter( inp, text_filter, &tfx );
1029                   }
1030                 iobuf_push_filter( inp, md_filter, &mfx );
1031                 while( iobuf_get(inp) != -1 )
1032                     ;
1033                 iobuf_close(inp); inp = NULL;
1034             }
1035             if( opt.verbose )
1036               log_printf ("\n");
1037         }
1038         else {
1039             /* read, so that the filter can calculate the digest */
1040             while( iobuf_get(inp) != -1 )
1041                 ;
1042         }
1043     }
1044     else {
1045         rc = write_plaintext_packet (out, inp, fname,
1046                                      opt.textmode && !outfile ? 't':'b');
1047     }
1048
1049     /* catch errors from above */
1050     if (rc)
1051         goto leave;
1052
1053     /* write the signatures */
1054     rc = write_signature_packets (sk_list, out, mfx.md,
1055                                   opt.textmode && !outfile? 0x01 : 0x00,
1056                                   0, duration, detached ? 'D':'S', NULL);
1057     if( rc )
1058         goto leave;
1059
1060
1061   leave:
1062     if( rc )
1063         iobuf_cancel(out);
1064     else {
1065         iobuf_close(out);
1066         if (encryptflag)
1067             write_status( STATUS_END_ENCRYPTION );
1068     }
1069     iobuf_close(inp);
1070     gcry_md_close ( mfx.md );
1071     release_sk_list( sk_list );
1072     release_pk_list( pk_list );
1073     recipient_digest_algo=0;
1074     release_progress_context (pfx);
1075     release_armor_context (afx);
1076     return rc;
1077 }
1078
1079
1080
1081 /****************
1082  * make a clear signature. note that opt.armor is not needed
1083  */
1084 int
1085 clearsign_file( const char *fname, strlist_t locusr, const char *outfile )
1086 {
1087     armor_filter_context_t *afx;
1088     progress_filter_context_t *pfx;
1089     gcry_md_hd_t textmd = NULL;
1090     IOBUF inp = NULL, out = NULL;
1091     PACKET pkt;
1092     int rc = 0;
1093     SK_LIST sk_list = NULL;
1094     SK_LIST sk_rover = NULL;
1095     u32 duration=0;
1096
1097     pfx = new_progress_context ();
1098     afx = new_armor_context ();
1099     init_packet( &pkt );
1100
1101     if (opt.ask_sig_expire && !opt.batch)
1102       duration = ask_expire_interval (1,opt.def_sig_expire);
1103     else
1104       duration = parse_expire_string (opt.def_sig_expire);
1105
1106     /* Note: In the old non-agent version the following call used to
1107        unprotect the secret key.  This is now done on demand by the agent.  */
1108     if( (rc=build_sk_list( locusr, &sk_list, PUBKEY_USAGE_SIG )) )
1109         goto leave;
1110
1111     /* prepare iobufs */
1112     inp = iobuf_open(fname);
1113     if (inp && is_secured_file (iobuf_get_fd (inp)))
1114       {
1115         iobuf_close (inp);
1116         inp = NULL;
1117         gpg_err_set_errno (EPERM);
1118       }
1119     if( !inp ) {
1120         rc = gpg_error_from_syserror ();
1121         log_error (_("can't open '%s': %s\n"),
1122                    fname? fname: "[stdin]", strerror(errno) );
1123         goto leave;
1124     }
1125     handle_progress (pfx, inp, fname);
1126
1127     if( outfile ) {
1128         if (is_secured_filename (outfile) ) {
1129             outfile = NULL;
1130             gpg_err_set_errno (EPERM);
1131         }
1132         else
1133           out = iobuf_create (outfile, 0);
1134         if( !out )
1135           {
1136             rc = gpg_error_from_syserror ();
1137             log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
1138             goto leave;
1139           }
1140         else if( opt.verbose )
1141             log_info(_("writing to '%s'\n"), outfile );
1142     }
1143     else if ((rc = open_outfile (-1, fname, 1, 0, &out)))
1144         goto leave;
1145
1146     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1147
1148     {
1149         const char *s;
1150         int any = 0;
1151         byte hashs_seen[256];
1152
1153         memset( hashs_seen, 0, sizeof hashs_seen );
1154         iobuf_writestr(out, "Hash: " );
1155         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1156             int i = hash_for (sk_rover->pk);
1157
1158             if( !hashs_seen[ i & 0xff ] ) {
1159                 s = gcry_md_algo_name ( i );
1160                 if( s ) {
1161                     hashs_seen[ i & 0xff ] = 1;
1162                     if( any )
1163                         iobuf_put(out, ',' );
1164                     iobuf_writestr(out, s );
1165                     any = 1;
1166                 }
1167             }
1168         }
1169         assert(any);
1170         iobuf_writestr(out, LF );
1171     }
1172
1173     if( opt.not_dash_escaped )
1174       iobuf_writestr( out,
1175                       "NotDashEscaped: You need "GPG_NAME
1176                       " to verify this message" LF );
1177     iobuf_writestr(out, LF );
1178
1179     if ( gcry_md_open (&textmd, 0, 0) )
1180       BUG ();
1181     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1182       gcry_md_enable (textmd, hash_for(sk_rover->pk));
1183
1184     if ( DBG_HASHING )
1185       gcry_md_debug ( textmd, "clearsign" );
1186
1187     copy_clearsig_text (out, inp, textmd, !opt.not_dash_escaped,
1188                         opt.escape_from);
1189     /* fixme: check for read errors */
1190
1191     /* now write the armor */
1192     afx->what = 2;
1193     push_armor_filter (afx, out);
1194
1195     /* Write the signatures.  */
1196     rc = write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C',
1197                                   NULL);
1198     if( rc )
1199         goto leave;
1200
1201   leave:
1202     if( rc )
1203         iobuf_cancel(out);
1204     else
1205         iobuf_close(out);
1206     iobuf_close(inp);
1207     gcry_md_close ( textmd );
1208     release_sk_list( sk_list );
1209     release_progress_context (pfx);
1210     release_armor_context (afx);
1211     return rc;
1212 }
1213
1214 /*
1215  * Sign and conventionally encrypt the given file.
1216  * FIXME: Far too much code is duplicated - revamp the whole file.
1217  */
1218 int
1219 sign_symencrypt_file (const char *fname, strlist_t locusr)
1220 {
1221     armor_filter_context_t *afx;
1222     progress_filter_context_t *pfx;
1223     compress_filter_context_t zfx;
1224     md_filter_context_t mfx;
1225     text_filter_context_t tfx;
1226     cipher_filter_context_t cfx;
1227     IOBUF inp = NULL, out = NULL;
1228     PACKET pkt;
1229     STRING2KEY *s2k = NULL;
1230     int rc = 0;
1231     SK_LIST sk_list = NULL;
1232     SK_LIST sk_rover = NULL;
1233     int algo;
1234     u32 duration=0;
1235     int canceled;
1236
1237     pfx = new_progress_context ();
1238     afx = new_armor_context ();
1239     memset( &zfx, 0, sizeof zfx);
1240     memset( &mfx, 0, sizeof mfx);
1241     memset( &tfx, 0, sizeof tfx);
1242     memset( &cfx, 0, sizeof cfx);
1243     init_packet( &pkt );
1244
1245     if (opt.ask_sig_expire && !opt.batch)
1246       duration = ask_expire_interval (1, opt.def_sig_expire);
1247     else
1248       duration = parse_expire_string (opt.def_sig_expire);
1249
1250     /* Note: In the old non-agent version the following call used to
1251        unprotect the secret key.  This is now done on demand by the agent.  */
1252     rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG);
1253     if (rc)
1254         goto leave;
1255
1256     /* prepare iobufs */
1257     inp = iobuf_open(fname);
1258     if (inp && is_secured_file (iobuf_get_fd (inp)))
1259       {
1260         iobuf_close (inp);
1261         inp = NULL;
1262         gpg_err_set_errno (EPERM);
1263       }
1264     if( !inp ) {
1265         rc = gpg_error_from_syserror ();
1266         log_error (_("can't open '%s': %s\n"),
1267                    fname? fname: "[stdin]", strerror(errno) );
1268         goto leave;
1269     }
1270     handle_progress (pfx, inp, fname);
1271
1272     /* prepare key */
1273     s2k = xmalloc_clear( sizeof *s2k );
1274     s2k->mode = opt.s2k_mode;
1275     s2k->hash_algo = S2K_DIGEST_ALGO;
1276
1277     algo = default_cipher_algo();
1278     if (!opt.quiet || !opt.batch)
1279         log_info (_("%s encryption will be used\n"),
1280                   openpgp_cipher_algo_name (algo) );
1281     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, &canceled);
1282
1283     if (!cfx.dek || !cfx.dek->keylen) {
1284         rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
1285         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1286         goto leave;
1287     }
1288
1289     /* We have no way to tell if the recipient can handle messages
1290        with an MDC, so this defaults to no.  Perhaps in a few years,
1291        this can be defaulted to yes.  Note that like regular
1292        encrypting, --force-mdc overrides --disable-mdc. */
1293     if(opt.force_mdc)
1294       cfx.dek->use_mdc=1;
1295
1296     /* now create the outfile */
1297     rc = open_outfile (-1, fname, opt.armor? 1:0, 0, &out);
1298     if (rc)
1299         goto leave;
1300
1301     /* prepare to calculate the MD over the input */
1302     if (opt.textmode)
1303         iobuf_push_filter (inp, text_filter, &tfx);
1304     if ( gcry_md_open (&mfx.md, 0, 0) )
1305       BUG ();
1306     if ( DBG_HASHING )
1307       gcry_md_debug (mfx.md, "symc-sign");
1308
1309     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1310       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
1311
1312     iobuf_push_filter (inp, md_filter, &mfx);
1313
1314     /* Push armor output filter */
1315     if (opt.armor)
1316         push_armor_filter (afx, out);
1317
1318     /* Write the symmetric key packet */
1319     /*(current filters: armor)*/
1320     {
1321         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1322         enc->version = 4;
1323         enc->cipher_algo = cfx.dek->algo;
1324         enc->s2k = *s2k;
1325         pkt.pkttype = PKT_SYMKEY_ENC;
1326         pkt.pkt.symkey_enc = enc;
1327         if( (rc = build_packet( out, &pkt )) )
1328             log_error("build symkey packet failed: %s\n", gpg_strerror (rc) );
1329         xfree(enc);
1330     }
1331
1332     /* Push the encryption filter */
1333     iobuf_push_filter( out, cipher_filter, &cfx );
1334
1335     /* Push the compress filter */
1336     if (default_compress_algo())
1337       push_compress_filter(out,&zfx,default_compress_algo());
1338
1339     /* Write the one-pass signature packets */
1340     /*(current filters: zip - encrypt - armor)*/
1341     rc = write_onepass_sig_packets (sk_list, out,
1342                                     opt.textmode? 0x01:0x00);
1343     if (rc)
1344       goto leave;
1345
1346     write_status_begin_signing (mfx.md);
1347
1348     /* Pipe data through all filters; i.e. write the signed stuff */
1349     /*(current filters: zip - encrypt - armor)*/
1350     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1351     if (rc)
1352         goto leave;
1353
1354     /* Write the signatures */
1355     /*(current filters: zip - encrypt - armor)*/
1356     rc = write_signature_packets (sk_list, out, mfx.md,
1357                                   opt.textmode? 0x01 : 0x00,
1358                                   0, duration, 'S', NULL);
1359     if( rc )
1360         goto leave;
1361
1362
1363   leave:
1364     if( rc )
1365         iobuf_cancel(out);
1366     else {
1367         iobuf_close(out);
1368         write_status( STATUS_END_ENCRYPTION );
1369     }
1370     iobuf_close(inp);
1371     release_sk_list( sk_list );
1372     gcry_md_close( mfx.md );
1373     xfree(cfx.dek);
1374     xfree(s2k);
1375     release_progress_context (pfx);
1376     release_armor_context (afx);
1377     return rc;
1378 }
1379
1380
1381 /****************
1382  * Create a signature packet for the given public key certificate and
1383  * the user id and return it in ret_sig. User signature class SIGCLASS
1384  * user-id is not used (and may be NULL if sigclass is 0x20) If
1385  * DIGEST_ALGO is 0 the function selects an appropriate one.
1386  * SIGVERSION gives the minimal required signature packet version;
1387  * this is needed so that special properties like local sign are not
1388  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1389  * the timestamp to use for the signature. 0 means "now" */
1390 int
1391 make_keysig_packet (PKT_signature **ret_sig, PKT_public_key *pk,
1392                     PKT_user_id *uid, PKT_public_key *subpk,
1393                     PKT_public_key *pksk,
1394                     int sigclass, int digest_algo,
1395                     u32 timestamp, u32 duration,
1396                     int (*mksubpkt)(PKT_signature *, void *), void *opaque,
1397                     const char *cache_nonce)
1398 {
1399     PKT_signature *sig;
1400     int rc=0;
1401     int sigversion;
1402     gcry_md_hd_t md;
1403
1404     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1405             || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1406             || sigclass == 0x30 || sigclass == 0x28 );
1407
1408     sigversion = 4;
1409     if (sigversion < pksk->version)
1410         sigversion = pksk->version;
1411
1412     if( !digest_algo )
1413       {
1414         /* Basically, this means use SHA1 always unless the user
1415            specified something (use whatever they said), or it's DSA
1416            (use the best match).  They still can't pick an
1417            inappropriate hash for DSA or the signature will fail.
1418            Note that this still allows the caller of
1419            make_keysig_packet to override the user setting if it
1420            must. */
1421
1422         if(opt.cert_digest_algo)
1423           digest_algo=opt.cert_digest_algo;
1424         else if(pksk->pubkey_algo == PUBKEY_ALGO_DSA)
1425           digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
1426         else if (pksk->pubkey_algo == PUBKEY_ALGO_ECDSA
1427                  || pksk->pubkey_algo == PUBKEY_ALGO_EDDSA)
1428           {
1429             if (openpgp_oid_is_ed25519 (pksk->pkey[0]))
1430               digest_algo = DIGEST_ALGO_SHA256;
1431             else
1432               digest_algo = match_dsa_hash
1433                 (ecdsa_qbits_from_Q (gcry_mpi_get_nbits (pksk->pkey[1]))/8);
1434           }
1435         else
1436           digest_algo = DEFAULT_DIGEST_ALGO;
1437       }
1438
1439     if ( gcry_md_open (&md, digest_algo, 0 ) )
1440       BUG ();
1441
1442     /* Hash the public key certificate. */
1443     hash_public_key( md, pk );
1444
1445     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1446       {
1447         /* hash the subkey binding/backsig/revocation */
1448         hash_public_key( md, subpk );
1449       }
1450     else if( sigclass != 0x1F && sigclass != 0x20 )
1451       {
1452         /* hash the user id */
1453         hash_uid (md, sigversion, uid);
1454       }
1455     /* and make the signature packet */
1456     sig = xmalloc_clear( sizeof *sig );
1457     sig->version = sigversion;
1458     sig->flags.exportable=1;
1459     sig->flags.revocable=1;
1460     keyid_from_pk (pksk, sig->keyid);
1461     sig->pubkey_algo = pksk->pubkey_algo;
1462     sig->digest_algo = digest_algo;
1463     if(timestamp)
1464       sig->timestamp=timestamp;
1465     else
1466       sig->timestamp=make_timestamp();
1467     if(duration)
1468       sig->expiredate=sig->timestamp+duration;
1469     sig->sig_class = sigclass;
1470
1471     build_sig_subpkt_from_sig( sig );
1472     mk_notation_policy_etc (sig, pk, pksk);
1473
1474     /* Crucial that the call to mksubpkt comes LAST before the calls
1475        to finalize the sig as that makes it possible for the mksubpkt
1476        function to get a reliable pointer to the subpacket area. */
1477     if (mksubpkt)
1478         rc = (*mksubpkt)( sig, opaque );
1479
1480     if( !rc ) {
1481         hash_sigversion_to_magic (md, sig);
1482         gcry_md_final (md);
1483
1484         rc = complete_sig (sig, pksk, md, cache_nonce);
1485     }
1486
1487     gcry_md_close (md);
1488     if( rc )
1489         free_seckey_enc( sig );
1490     else
1491         *ret_sig = sig;
1492     return rc;
1493 }
1494
1495
1496
1497 /****************
1498  * Create a new signature packet based on an existing one.
1499  * Only user ID signatures are supported for now.
1500  * PK is the public key to work on.
1501  * PKSK is the key used to make the signature.
1502  *
1503  * TODO: Merge this with make_keysig_packet.
1504  */
1505 int
1506 update_keysig_packet( PKT_signature **ret_sig,
1507                       PKT_signature *orig_sig,
1508                       PKT_public_key *pk,
1509                       PKT_user_id *uid,
1510                       PKT_public_key *subpk,
1511                       PKT_public_key *pksk,
1512                       int (*mksubpkt)(PKT_signature *, void *),
1513                       void *opaque)
1514 {
1515     PKT_signature *sig;
1516     int rc = 0;
1517     int digest_algo;
1518     gcry_md_hd_t md;
1519
1520     if ((!orig_sig || !pk || !pksk)
1521         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1522         || (orig_sig->sig_class == 0x18 && !subpk))
1523       return GPG_ERR_GENERAL;
1524
1525     if ( opt.cert_digest_algo )
1526       digest_algo = opt.cert_digest_algo;
1527     else
1528       digest_algo = orig_sig->digest_algo;
1529
1530     if ( gcry_md_open (&md, digest_algo, 0 ) )
1531       BUG ();
1532
1533     /* Hash the public key certificate and the user id. */
1534     hash_public_key( md, pk );
1535
1536     if( orig_sig->sig_class == 0x18 )
1537       hash_public_key( md, subpk );
1538     else
1539       hash_uid (md, orig_sig->version, uid);
1540
1541     /* create a new signature packet */
1542     sig = copy_signature (NULL, orig_sig);
1543
1544     sig->digest_algo=digest_algo;
1545
1546     /* We need to create a new timestamp so that new sig expiration
1547        calculations are done correctly... */
1548     sig->timestamp=make_timestamp();
1549
1550     /* ... but we won't make a timestamp earlier than the existing
1551        one. */
1552     while(sig->timestamp<=orig_sig->timestamp)
1553       {
1554         gnupg_sleep (1);
1555         sig->timestamp=make_timestamp();
1556       }
1557
1558     /* Note that already expired sigs will remain expired (with a
1559        duration of 1) since build-packet.c:build_sig_subpkt_from_sig
1560        detects this case. */
1561
1562     /* Put the updated timestamp into the sig.  Note that this will
1563        automagically lower any sig expiration dates to correctly
1564        correspond to the differences in the timestamps (i.e. the
1565        duration will shrink).  */
1566     build_sig_subpkt_from_sig( sig );
1567
1568     if (mksubpkt)
1569       rc = (*mksubpkt)(sig, opaque);
1570
1571     if (!rc) {
1572         hash_sigversion_to_magic (md, sig);
1573         gcry_md_final (md);
1574
1575         rc = complete_sig (sig, pksk, md, NULL);
1576     }
1577
1578     gcry_md_close (md);
1579     if( rc )
1580         free_seckey_enc (sig);
1581     else
1582         *ret_sig = sig;
1583     return rc;
1584 }