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