cfac5de76fe2bc1e032ce48cbbc9235223f068ad
[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, 0, 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   --preferred-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 --preferred-digest-prefs that is
427   usable for the pubkey algorithm.  If --preferred-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_ECDSA
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 (PGP2 && pk->pubkey_algo == PUBKEY_ALGO_RSA && pk->version < 4 )
513     {
514       /* Old-style PGP only understands MD5 */
515       return DIGEST_ALGO_MD5;
516     }
517   else if (opt.personal_digest_prefs)
518     {
519       /* It's not DSA, so we can use whatever the first hash algorithm
520          is in the pref list */
521       return opt.personal_digest_prefs[0].value;
522     }
523   else
524     return DEFAULT_DIGEST_ALGO;
525 }
526
527
528 /* Return true iff all keys in SK_LIST are old style (v3 RSA).  */
529 static int
530 only_old_style (SK_LIST sk_list)
531 {
532   SK_LIST sk_rover = NULL;
533   int old_style = 0;
534
535   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
536     {
537       PKT_public_key *pk = sk_rover->pk;
538
539       if (pk->pubkey_algo == PUBKEY_ALGO_RSA && pk->version < 4)
540         old_style = 1;
541       else
542         return 0;
543     }
544   return old_style;
545 }
546
547
548 static void
549 print_status_sig_created (PKT_public_key *pk, PKT_signature *sig, int what)
550 {
551   byte array[MAX_FINGERPRINT_LEN];
552   char buf[100+MAX_FINGERPRINT_LEN*2];
553   size_t n;
554
555   snprintf (buf, sizeof buf - 2*MAX_FINGERPRINT_LEN, "%c %d %d %02x %lu ",
556             what, sig->pubkey_algo, sig->digest_algo, sig->sig_class,
557             (ulong)sig->timestamp );
558   fingerprint_from_pk (pk, array, &n);
559   bin2hex (array, n, buf + strlen (buf));
560
561   write_status_text( STATUS_SIG_CREATED, buf );
562 }
563
564
565 /*
566  * Loop over the secret certificates in SK_LIST and build the one pass
567  * signature packets.  OpenPGP says that the data should be bracket by
568  * the onepass-sig and signature-packet; so we build these onepass
569  * packet here in reverse order
570  */
571 static int
572 write_onepass_sig_packets (SK_LIST sk_list, IOBUF out, int sigclass )
573 {
574     int skcount;
575     SK_LIST sk_rover;
576
577     for (skcount=0, sk_rover=sk_list; sk_rover; sk_rover = sk_rover->next)
578         skcount++;
579
580     for (; skcount; skcount--) {
581         PKT_public_key *pk;
582         PKT_onepass_sig *ops;
583         PACKET pkt;
584         int i, rc;
585
586         for (i=0, sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
587             if (++i == skcount)
588                 break;
589         }
590
591         pk = sk_rover->pk;
592         ops = xmalloc_clear (sizeof *ops);
593         ops->sig_class = sigclass;
594         ops->digest_algo = hash_for (pk);
595         ops->pubkey_algo = pk->pubkey_algo;
596         keyid_from_pk (pk, ops->keyid);
597         ops->last = (skcount == 1);
598
599         init_packet(&pkt);
600         pkt.pkttype = PKT_ONEPASS_SIG;
601         pkt.pkt.onepass_sig = ops;
602         rc = build_packet (out, &pkt);
603         free_packet (&pkt);
604         if (rc) {
605             log_error ("build onepass_sig packet failed: %s\n",
606                        g10_errstr(rc));
607             return rc;
608         }
609     }
610
611     return 0;
612 }
613
614 /*
615  * Helper to write the plaintext (literal data) packet
616  */
617 static int
618 write_plaintext_packet (IOBUF out, IOBUF inp, const char *fname, int ptmode)
619 {
620     PKT_plaintext *pt = NULL;
621     u32 filesize;
622     int rc = 0;
623
624     if (!opt.no_literal)
625       pt=setup_plaintext_name(fname,inp);
626
627     /* try to calculate the length of the data */
628     if ( !iobuf_is_pipe_filename (fname) && *fname )
629       {
630         off_t tmpsize;
631         int overflow;
632
633         if( !(tmpsize = iobuf_get_filelength(inp, &overflow))
634             && !overflow && opt.verbose)
635           log_info (_("WARNING: '%s' is an empty file\n"), fname);
636
637         /* We can't encode the length of very large files because
638            OpenPGP uses only 32 bit for file sizes.  So if the size of
639            a file is larger than 2^32 minus some bytes for packet
640            headers, we switch to partial length encoding. */
641         if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
642           filesize = tmpsize;
643         else
644           filesize = 0;
645
646         /* Because the text_filter modifies the length of the
647          * data, it is not possible to know the used length
648          * without a double read of the file - to avoid that
649          * we simple use partial length packets. */
650         if ( ptmode == 't' )
651           filesize = 0;
652       }
653     else
654       filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
655
656     if (!opt.no_literal) {
657         PACKET pkt;
658
659         pt->timestamp = make_timestamp ();
660         pt->mode = ptmode;
661         pt->len = filesize;
662         pt->new_ctb = !pt->len && !RFC1991;
663         pt->buf = inp;
664         init_packet(&pkt);
665         pkt.pkttype = PKT_PLAINTEXT;
666         pkt.pkt.plaintext = pt;
667         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
668         if( (rc = build_packet (out, &pkt)) )
669             log_error ("build_packet(PLAINTEXT) failed: %s\n",
670                        g10_errstr(rc) );
671         pt->buf = NULL;
672     }
673     else {
674         byte copy_buffer[4096];
675         int  bytes_copied;
676
677         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
678             if ( (rc=iobuf_write(out, copy_buffer, bytes_copied)) ) {
679                 log_error ("copying input to output failed: %s\n",
680                            gpg_strerror (rc));
681                 break;
682             }
683         wipememory(copy_buffer,4096); /* burn buffer */
684     }
685     /* fixme: it seems that we never freed pt/pkt */
686
687     return rc;
688 }
689
690 /*
691  * Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
692  * hash which will not be changes here.
693  */
694 static int
695 write_signature_packets (SK_LIST sk_list, IOBUF out, gcry_md_hd_t hash,
696                          int sigclass, u32 timestamp, u32 duration,
697                          int status_letter, const char *cache_nonce)
698 {
699   SK_LIST sk_rover;
700
701   /* Loop over the certificates with secret keys. */
702   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
703     {
704       PKT_public_key *pk;
705       PKT_signature *sig;
706       gcry_md_hd_t md;
707       int rc;
708
709       pk = sk_rover->pk;
710
711       /* Build the signature packet.  */
712       sig = xmalloc_clear (sizeof *sig);
713       if (opt.force_v3_sigs || RFC1991)
714         sig->version = 3;
715       else if (duration || opt.sig_policy_url
716                || opt.sig_notations || opt.sig_keyserver_url)
717         sig->version = 4;
718       else
719         sig->version = pk->version;
720
721       keyid_from_pk (pk, sig->keyid);
722       sig->digest_algo = hash_for (pk);
723       sig->pubkey_algo = pk->pubkey_algo;
724       if (timestamp)
725         sig->timestamp = timestamp;
726       else
727         sig->timestamp = make_timestamp();
728       if (duration)
729         sig->expiredate = sig->timestamp + duration;
730       sig->sig_class = sigclass;
731
732       if (gcry_md_copy (&md, hash))
733         BUG ();
734
735       if (sig->version >= 4)
736         {
737           build_sig_subpkt_from_sig (sig);
738           mk_notation_policy_etc (sig, pk, NULL);
739         }
740
741       hash_sigversion_to_magic (md, sig);
742       gcry_md_final (md);
743
744       rc = do_sign (pk, sig, md, hash_for (pk), cache_nonce);
745       gcry_md_close (md);
746       if (!rc)
747         {
748           /* Write the packet.  */
749           PACKET pkt;
750
751           init_packet (&pkt);
752           pkt.pkttype = PKT_SIGNATURE;
753           pkt.pkt.signature = sig;
754           rc = build_packet (out, &pkt);
755           if (!rc && is_status_enabled())
756             print_status_sig_created (pk, sig, status_letter);
757           free_packet (&pkt);
758           if (rc)
759             log_error ("build signature packet failed: %s\n", gpg_strerror (rc));
760         }
761       if (rc)
762         return rc;
763     }
764
765   return 0;
766 }
767
768
769 /****************
770  * Sign the files whose names are in FILENAME.
771  * If DETACHED has the value true,
772  * make a detached signature.  If FILENAMES->d is NULL read from stdin
773  * and ignore the detached mode.  Sign the file with all secret keys
774  * which can be taken from LOCUSR, if this is NULL, use the default one
775  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
776  * signed data for these users.
777  * If OUTFILE is not NULL; this file is used for output and the function
778  * does not ask for overwrite permission; output is then always
779  * uncompressed, non-armored and in binary mode.
780  */
781 int
782 sign_file (ctrl_t ctrl, strlist_t filenames, int detached, strlist_t locusr,
783            int encryptflag, strlist_t remusr, const char *outfile )
784 {
785     const char *fname;
786     armor_filter_context_t *afx;
787     compress_filter_context_t zfx;
788     md_filter_context_t mfx;
789     text_filter_context_t tfx;
790     progress_filter_context_t *pfx;
791     encrypt_filter_context_t efx;
792     IOBUF inp = NULL, out = NULL;
793     PACKET pkt;
794     int rc = 0;
795     PK_LIST pk_list = NULL;
796     SK_LIST sk_list = NULL;
797     SK_LIST sk_rover = NULL;
798     int multifile = 0;
799     u32 duration=0;
800
801     pfx = new_progress_context ();
802     afx = new_armor_context ();
803     memset( &zfx, 0, sizeof zfx);
804     memset( &mfx, 0, sizeof mfx);
805     memset( &efx, 0, sizeof efx);
806     init_packet( &pkt );
807
808     if( filenames ) {
809         fname = filenames->d;
810         multifile = !!filenames->next;
811     }
812     else
813         fname = NULL;
814
815     if( fname && filenames->next && (!detached || encryptflag) )
816         log_bug("multiple files can only be detached signed");
817
818     if(encryptflag==2
819        && (rc=setup_symkey(&efx.symkey_s2k,&efx.symkey_dek)))
820       goto leave;
821
822     if(!opt.force_v3_sigs && !RFC1991)
823       {
824         if(opt.ask_sig_expire && !opt.batch)
825           duration=ask_expire_interval(1,opt.def_sig_expire);
826         else
827           duration=parse_expire_string(opt.def_sig_expire);
828       }
829
830     /* Note: In the old non-agent version the following call used to
831        unprotect the secret key.  This is now done on demand by the agent.  */
832     if( (rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG )) )
833         goto leave;
834
835     if(PGP2 && !only_old_style(sk_list))
836       {
837         log_info(_("you can only detach-sign with PGP 2.x style keys "
838                    "while in --pgp2 mode\n"));
839         compliance_failure();
840       }
841
842     if (encryptflag
843         && (rc=build_pk_list (ctrl, remusr, &pk_list, PUBKEY_USAGE_ENC)))
844       goto leave;
845
846     /* prepare iobufs */
847     if( multifile )  /* have list of filenames */
848         inp = NULL; /* we do it later */
849     else {
850       inp = iobuf_open(fname);
851       if (inp && is_secured_file (iobuf_get_fd (inp)))
852         {
853           iobuf_close (inp);
854           inp = NULL;
855           gpg_err_set_errno (EPERM);
856         }
857       if( !inp )
858         {
859           rc = gpg_error_from_syserror ();
860           log_error (_("can't open '%s': %s\n"), fname? fname: "[stdin]",
861                      strerror(errno) );
862           goto leave;
863         }
864
865         handle_progress (pfx, inp, fname);
866     }
867
868     if( outfile ) {
869         if (is_secured_filename ( outfile )) {
870             out = NULL;
871             gpg_err_set_errno (EPERM);
872         }
873         else
874             out = iobuf_create( outfile );
875         if( !out )
876           {
877             rc = gpg_error_from_syserror ();
878             log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
879             goto leave;
880           }
881         else if( opt.verbose )
882             log_info(_("writing to '%s'\n"), outfile );
883     }
884     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname,
885                                  opt.armor? 1: detached? 2:0, &out )))
886         goto leave;
887
888     /* prepare to calculate the MD over the input */
889     if( opt.textmode && !outfile && !multifile )
890       {
891         memset( &tfx, 0, sizeof tfx);
892         iobuf_push_filter( inp, text_filter, &tfx );
893       }
894
895     if ( gcry_md_open (&mfx.md, 0, 0) )
896       BUG ();
897     if (DBG_HASHING)
898       gcry_md_debug (mfx.md, "sign");
899
900     /* If we're encrypting and signing, it is reasonable to pick the
901        hash algorithm to use out of the recipient key prefs.  This is
902        best effort only, as in a DSA2 and smartcard world there are
903        cases where we cannot please everyone with a single hash (DSA2
904        wants >160 and smartcards want =160).  In the future this could
905        be more complex with different hashes for each sk, but the
906        current design requires a single hash for all SKs. */
907     if(pk_list)
908       {
909         if(opt.def_digest_algo)
910           {
911             if(!opt.expert &&
912                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
913                                       opt.def_digest_algo,
914                                       NULL)!=opt.def_digest_algo)
915           log_info(_("WARNING: forcing digest algorithm %s (%d)"
916                      " violates recipient preferences\n"),
917                    gcry_md_algo_name (opt.def_digest_algo),
918                    opt.def_digest_algo );
919           }
920         else
921           {
922             int algo, smartcard=0;
923             union pref_hint hint;
924
925             hint.digest_length = 0;
926
927             /* Of course, if the recipient asks for something
928                unreasonable (like the wrong hash for a DSA key) then
929                don't do it.  Check all sk's - if any are DSA or live
930                on a smartcard, then the hash has restrictions and we
931                may not be able to give the recipient what they want.
932                For DSA, pass a hint for the largest q we have.  Note
933                that this means that a q>160 key will override a q=160
934                key and force the use of truncation for the q=160 key.
935                The alternative would be to ignore the recipient prefs
936                completely and get a different hash for each DSA key in
937                hash_for().  The override behavior here is more or less
938                reasonable as it is under the control of the user which
939                keys they sign with for a given message and the fact
940                that the message with multiple signatures won't be
941                usable on an implementation that doesn't understand
942                DSA2 anyway. */
943
944             for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
945               {
946                 if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_DSA
947                     || (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA
948                         && !openpgp_oid_is_ed25519 (sk_rover->pk->pkey[1])))
949                   {
950                     int temp_hashlen = (gcry_mpi_get_nbits
951                                         (sk_rover->pk->pkey[1]));
952
953                     if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
954                       temp_hashlen = ecdsa_qbits_from_Q (temp_hashlen);
955                     temp_hashlen = (temp_hashlen+7)/8;
956
957                     /* Pick a hash that is large enough for our
958                        largest q */
959
960                     if (hint.digest_length<temp_hashlen)
961                       hint.digest_length=temp_hashlen;
962                   }
963                 /* FIXME: need toall gpg-agent */
964                 /* else if (sk_rover->pk->is_protected */
965                 /*          && sk_rover->pk->protect.s2k.mode == 1002) */
966                 /*   smartcard = 1;  */
967               }
968
969             /* Current smartcards only do 160-bit hashes.  If we have
970                to have a >160-bit hash, then we can't use the
971                recipient prefs as we'd need both =160 and >160 at the
972                same time and recipient prefs currently require a
973                single hash for all signatures.  All this may well have
974                to change as the cards add algorithms. */
975
976             if (!smartcard || (smartcard && hint.digest_length==20))
977               if ( (algo=
978                    select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint)) > 0)
979                 recipient_digest_algo=algo;
980           }
981       }
982
983     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
984       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
985
986     if( !multifile )
987         iobuf_push_filter( inp, md_filter, &mfx );
988
989     if( detached && !encryptflag && !RFC1991 )
990         afx->what = 2;
991
992     if( opt.armor && !outfile  )
993         push_armor_filter (afx, out);
994
995     if( encryptflag ) {
996         efx.pk_list = pk_list;
997         /* fixme: set efx.cfx.datalen if known */
998         iobuf_push_filter( out, encrypt_filter, &efx );
999     }
1000
1001     if( opt.compress_algo && !outfile && ( !detached || opt.compress_sigs) )
1002       {
1003         int compr_algo=opt.compress_algo;
1004
1005         /* If not forced by user */
1006         if(compr_algo==-1)
1007           {
1008             /* If we're not encrypting, then select_algo_from_prefs
1009                will fail and we'll end up with the default.  If we are
1010                encrypting, select_algo_from_prefs cannot fail since
1011                there is an assumed preference for uncompressed data.
1012                Still, if it did fail, we'll also end up with the
1013                default. */
1014
1015             if((compr_algo=
1016                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
1017               compr_algo=default_compress_algo();
1018           }
1019         else if(!opt.expert && pk_list
1020                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
1021                                           compr_algo,NULL)!=compr_algo)
1022           log_info(_("WARNING: forcing compression algorithm %s (%d)"
1023                      " violates recipient preferences\n"),
1024                    compress_algo_to_string(compr_algo),compr_algo);
1025
1026         /* algo 0 means no compression */
1027         if( compr_algo )
1028           push_compress_filter(out,&zfx,compr_algo);
1029       }
1030
1031     /* Write the one-pass signature packets if needed */
1032     if (!detached && !RFC1991) {
1033         rc = write_onepass_sig_packets (sk_list, out,
1034                                         opt.textmode && !outfile ? 0x01:0x00);
1035         if (rc)
1036             goto leave;
1037     }
1038
1039     write_status_begin_signing (mfx.md);
1040
1041     /* Setup the inner packet. */
1042     if( detached ) {
1043         if( multifile ) {
1044             strlist_t sl;
1045
1046             if( opt.verbose )
1047                 log_info(_("signing:") );
1048             /* must walk reverse trough this list */
1049             for( sl = strlist_last(filenames); sl;
1050                         sl = strlist_prev( filenames, sl ) ) {
1051                 inp = iobuf_open(sl->d);
1052                 if (inp && is_secured_file (iobuf_get_fd (inp)))
1053                   {
1054                     iobuf_close (inp);
1055                     inp = NULL;
1056                     gpg_err_set_errno (EPERM);
1057                   }
1058                 if( !inp )
1059                   {
1060                     rc = gpg_error_from_syserror ();
1061                     log_error(_("can't open '%s': %s\n"),
1062                               sl->d,strerror(errno));
1063                     goto leave;
1064                   }
1065                 handle_progress (pfx, inp, sl->d);
1066                 if( opt.verbose )
1067                     fprintf(stderr, " '%s'", sl->d );
1068                 if(opt.textmode)
1069                   {
1070                     memset( &tfx, 0, sizeof tfx);
1071                     iobuf_push_filter( inp, text_filter, &tfx );
1072                   }
1073                 iobuf_push_filter( inp, md_filter, &mfx );
1074                 while( iobuf_get(inp) != -1 )
1075                     ;
1076                 iobuf_close(inp); inp = NULL;
1077             }
1078             if( opt.verbose )
1079                 putc( '\n', stderr );
1080         }
1081         else {
1082             /* read, so that the filter can calculate the digest */
1083             while( iobuf_get(inp) != -1 )
1084                 ;
1085         }
1086     }
1087     else {
1088         rc = write_plaintext_packet (out, inp, fname,
1089                                      opt.textmode && !outfile ? 't':'b');
1090     }
1091
1092     /* catch errors from above */
1093     if (rc)
1094         goto leave;
1095
1096     /* write the signatures */
1097     rc = write_signature_packets (sk_list, out, mfx.md,
1098                                   opt.textmode && !outfile? 0x01 : 0x00,
1099                                   0, duration, detached ? 'D':'S', NULL);
1100     if( rc )
1101         goto leave;
1102
1103
1104   leave:
1105     if( rc )
1106         iobuf_cancel(out);
1107     else {
1108         iobuf_close(out);
1109         if (encryptflag)
1110             write_status( STATUS_END_ENCRYPTION );
1111     }
1112     iobuf_close(inp);
1113     gcry_md_close ( mfx.md );
1114     release_sk_list( sk_list );
1115     release_pk_list( pk_list );
1116     recipient_digest_algo=0;
1117     release_progress_context (pfx);
1118     release_armor_context (afx);
1119     return rc;
1120 }
1121
1122
1123
1124 /****************
1125  * make a clear signature. note that opt.armor is not needed
1126  */
1127 int
1128 clearsign_file( const char *fname, strlist_t locusr, const char *outfile )
1129 {
1130     armor_filter_context_t *afx;
1131     progress_filter_context_t *pfx;
1132     gcry_md_hd_t textmd = NULL;
1133     IOBUF inp = NULL, out = NULL;
1134     PACKET pkt;
1135     int rc = 0;
1136     SK_LIST sk_list = NULL;
1137     SK_LIST sk_rover = NULL;
1138     int old_style = RFC1991;
1139     int only_md5 = 0;
1140     u32 duration=0;
1141
1142     pfx = new_progress_context ();
1143     afx = new_armor_context ();
1144     init_packet( &pkt );
1145
1146     if(!opt.force_v3_sigs && !RFC1991)
1147       {
1148         if(opt.ask_sig_expire && !opt.batch)
1149           duration=ask_expire_interval(1,opt.def_sig_expire);
1150         else
1151           duration=parse_expire_string(opt.def_sig_expire);
1152       }
1153
1154     /* Note: In the old non-agent version the following call used to
1155        unprotect the secret key.  This is now done on demand by the agent.  */
1156     if( (rc=build_sk_list( locusr, &sk_list, PUBKEY_USAGE_SIG )) )
1157         goto leave;
1158
1159     if( !old_style && !duration )
1160         old_style = only_old_style( sk_list );
1161
1162     if(PGP2 && !only_old_style(sk_list))
1163       {
1164         log_info(_("you can only clearsign with PGP 2.x style keys "
1165                    "while in --pgp2 mode\n"));
1166         compliance_failure();
1167       }
1168
1169     /* prepare iobufs */
1170     inp = iobuf_open(fname);
1171     if (inp && is_secured_file (iobuf_get_fd (inp)))
1172       {
1173         iobuf_close (inp);
1174         inp = NULL;
1175         gpg_err_set_errno (EPERM);
1176       }
1177     if( !inp ) {
1178         rc = gpg_error_from_syserror ();
1179         log_error (_("can't open '%s': %s\n"),
1180                    fname? fname: "[stdin]", strerror(errno) );
1181         goto leave;
1182     }
1183     handle_progress (pfx, inp, fname);
1184
1185     if( outfile ) {
1186         if (is_secured_filename (outfile) ) {
1187             outfile = NULL;
1188             gpg_err_set_errno (EPERM);
1189         }
1190         else
1191             out = iobuf_create( outfile );
1192         if( !out )
1193           {
1194             rc = gpg_error_from_syserror ();
1195             log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
1196             goto leave;
1197           }
1198         else if( opt.verbose )
1199             log_info(_("writing to '%s'\n"), outfile );
1200     }
1201     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname, 1, &out )) )
1202         goto leave;
1203
1204     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1205
1206     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1207       {
1208         if (hash_for (sk_rover->pk) == DIGEST_ALGO_MD5)
1209           only_md5 = 1;
1210         else
1211           {
1212             only_md5 = 0;
1213             break;
1214           }
1215       }
1216
1217     if( !(old_style && only_md5) ) {
1218         const char *s;
1219         int any = 0;
1220         byte hashs_seen[256];
1221
1222         memset( hashs_seen, 0, sizeof hashs_seen );
1223         iobuf_writestr(out, "Hash: " );
1224         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1225             int i = hash_for (sk_rover->pk);
1226
1227             if( !hashs_seen[ i & 0xff ] ) {
1228                 s = gcry_md_algo_name ( i );
1229                 if( s ) {
1230                     hashs_seen[ i & 0xff ] = 1;
1231                     if( any )
1232                         iobuf_put(out, ',' );
1233                     iobuf_writestr(out, s );
1234                     any = 1;
1235                 }
1236             }
1237         }
1238         assert(any);
1239         iobuf_writestr(out, LF );
1240     }
1241
1242     if( opt.not_dash_escaped )
1243       iobuf_writestr( out,
1244                   "NotDashEscaped: You need GnuPG to verify this message" LF );
1245     iobuf_writestr(out, LF );
1246
1247     if ( gcry_md_open (&textmd, 0, 0) )
1248       BUG ();
1249     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1250       gcry_md_enable (textmd, hash_for(sk_rover->pk));
1251
1252     if ( DBG_HASHING )
1253       gcry_md_debug ( textmd, "clearsign" );
1254
1255     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
1256                         opt.escape_from, (old_style && only_md5) );
1257     /* fixme: check for read errors */
1258
1259     /* now write the armor */
1260     afx->what = 2;
1261     push_armor_filter (afx, out);
1262
1263     /* Write the signatures.  */
1264     rc = write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C',
1265                                   NULL);
1266     if( rc )
1267         goto leave;
1268
1269   leave:
1270     if( rc )
1271         iobuf_cancel(out);
1272     else
1273         iobuf_close(out);
1274     iobuf_close(inp);
1275     gcry_md_close ( textmd );
1276     release_sk_list( sk_list );
1277     release_progress_context (pfx);
1278     release_armor_context (afx);
1279     return rc;
1280 }
1281
1282 /*
1283  * Sign and conventionally encrypt the given file.
1284  * FIXME: Far too much code is duplicated - revamp the whole file.
1285  */
1286 int
1287 sign_symencrypt_file (const char *fname, strlist_t locusr)
1288 {
1289     armor_filter_context_t *afx;
1290     progress_filter_context_t *pfx;
1291     compress_filter_context_t zfx;
1292     md_filter_context_t mfx;
1293     text_filter_context_t tfx;
1294     cipher_filter_context_t cfx;
1295     IOBUF inp = NULL, out = NULL;
1296     PACKET pkt;
1297     STRING2KEY *s2k = NULL;
1298     int rc = 0;
1299     SK_LIST sk_list = NULL;
1300     SK_LIST sk_rover = NULL;
1301     int algo;
1302     u32 duration=0;
1303     int canceled;
1304
1305     pfx = new_progress_context ();
1306     afx = new_armor_context ();
1307     memset( &zfx, 0, sizeof zfx);
1308     memset( &mfx, 0, sizeof mfx);
1309     memset( &tfx, 0, sizeof tfx);
1310     memset( &cfx, 0, sizeof cfx);
1311     init_packet( &pkt );
1312
1313     if(!opt.force_v3_sigs && !RFC1991)
1314       {
1315         if(opt.ask_sig_expire && !opt.batch)
1316           duration=ask_expire_interval(1,opt.def_sig_expire);
1317         else
1318           duration=parse_expire_string(opt.def_sig_expire);
1319       }
1320
1321     /* Note: In the old non-agent version the following call used to
1322        unprotect the secret key.  This is now done on demand by the agent.  */
1323     rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG);
1324     if (rc)
1325         goto leave;
1326
1327     /* prepare iobufs */
1328     inp = iobuf_open(fname);
1329     if (inp && is_secured_file (iobuf_get_fd (inp)))
1330       {
1331         iobuf_close (inp);
1332         inp = NULL;
1333         gpg_err_set_errno (EPERM);
1334       }
1335     if( !inp ) {
1336         rc = gpg_error_from_syserror ();
1337         log_error (_("can't open '%s': %s\n"),
1338                    fname? fname: "[stdin]", strerror(errno) );
1339         goto leave;
1340     }
1341     handle_progress (pfx, inp, fname);
1342
1343     /* prepare key */
1344     s2k = xmalloc_clear( sizeof *s2k );
1345     s2k->mode = RFC1991? 0:opt.s2k_mode;
1346     s2k->hash_algo = S2K_DIGEST_ALGO;
1347
1348     algo = default_cipher_algo();
1349     if (!opt.quiet || !opt.batch)
1350         log_info (_("%s encryption will be used\n"),
1351                   openpgp_cipher_algo_name (algo) );
1352     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, &canceled);
1353
1354     if (!cfx.dek || !cfx.dek->keylen) {
1355         rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
1356         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1357         goto leave;
1358     }
1359
1360     /* We have no way to tell if the recipient can handle messages
1361        with an MDC, so this defaults to no.  Perhaps in a few years,
1362        this can be defaulted to yes.  Note that like regular
1363        encrypting, --force-mdc overrides --disable-mdc. */
1364     if(opt.force_mdc)
1365       cfx.dek->use_mdc=1;
1366
1367     /* now create the outfile */
1368     rc = open_outfile (GNUPG_INVALID_FD, fname, opt.armor? 1:0, &out);
1369     if (rc)
1370         goto leave;
1371
1372     /* prepare to calculate the MD over the input */
1373     if (opt.textmode)
1374         iobuf_push_filter (inp, text_filter, &tfx);
1375     if ( gcry_md_open (&mfx.md, 0, 0) )
1376       BUG ();
1377     if ( DBG_HASHING )
1378       gcry_md_debug (mfx.md, "symc-sign");
1379
1380     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1381       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
1382
1383     iobuf_push_filter (inp, md_filter, &mfx);
1384
1385     /* Push armor output filter */
1386     if (opt.armor)
1387         push_armor_filter (afx, out);
1388
1389     /* Write the symmetric key packet */
1390     /*(current filters: armor)*/
1391     if (!RFC1991) {
1392         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1393         enc->version = 4;
1394         enc->cipher_algo = cfx.dek->algo;
1395         enc->s2k = *s2k;
1396         pkt.pkttype = PKT_SYMKEY_ENC;
1397         pkt.pkt.symkey_enc = enc;
1398         if( (rc = build_packet( out, &pkt )) )
1399             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1400         xfree(enc);
1401     }
1402
1403     /* Push the encryption filter */
1404     iobuf_push_filter( out, cipher_filter, &cfx );
1405
1406     /* Push the compress filter */
1407     if (default_compress_algo())
1408       push_compress_filter(out,&zfx,default_compress_algo());
1409
1410     /* Write the one-pass signature packets */
1411     /*(current filters: zip - encrypt - armor)*/
1412     if (!RFC1991) {
1413         rc = write_onepass_sig_packets (sk_list, out,
1414                                         opt.textmode? 0x01:0x00);
1415         if (rc)
1416             goto leave;
1417     }
1418
1419     write_status_begin_signing (mfx.md);
1420
1421     /* Pipe data through all filters; i.e. write the signed stuff */
1422     /*(current filters: zip - encrypt - armor)*/
1423     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1424     if (rc)
1425         goto leave;
1426
1427     /* Write the signatures */
1428     /*(current filters: zip - encrypt - armor)*/
1429     rc = write_signature_packets (sk_list, out, mfx.md,
1430                                   opt.textmode? 0x01 : 0x00,
1431                                   0, duration, 'S', NULL);
1432     if( rc )
1433         goto leave;
1434
1435
1436   leave:
1437     if( rc )
1438         iobuf_cancel(out);
1439     else {
1440         iobuf_close(out);
1441         write_status( STATUS_END_ENCRYPTION );
1442     }
1443     iobuf_close(inp);
1444     release_sk_list( sk_list );
1445     gcry_md_close( mfx.md );
1446     xfree(cfx.dek);
1447     xfree(s2k);
1448     release_progress_context (pfx);
1449     release_armor_context (afx);
1450     return rc;
1451 }
1452
1453
1454 /****************
1455  * Create a signature packet for the given public key certificate and
1456  * the user id and return it in ret_sig. User signature class SIGCLASS
1457  * user-id is not used (and may be NULL if sigclass is 0x20) If
1458  * DIGEST_ALGO is 0 the function selects an appropriate one.
1459  * SIGVERSION gives the minimal required signature packet version;
1460  * this is needed so that special properties like local sign are not
1461  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1462  * the timestamp to use for the signature. 0 means "now" */
1463 int
1464 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1465                     PKT_user_id *uid, PKT_public_key *subpk,
1466                     PKT_public_key *pksk,
1467                     int sigclass, int digest_algo,
1468                     int sigversion, u32 timestamp, u32 duration,
1469                     int (*mksubpkt)(PKT_signature *, void *), void *opaque,
1470                     const char *cache_nonce)
1471 {
1472     PKT_signature *sig;
1473     int rc=0;
1474     gcry_md_hd_t md;
1475
1476     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1477             || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1478             || sigclass == 0x30 || sigclass == 0x28 );
1479
1480     if (opt.force_v4_certs)
1481         sigversion = 4;
1482
1483     if (sigversion < pksk->version)
1484         sigversion = pksk->version;
1485
1486     /* If you are making a signature on a v4 key using your v3 key, it
1487        doesn't make sense to generate a v3 sig.  After all, no v3-only
1488        PGP implementation could understand the v4 key in the first
1489        place.  Note that this implies that a signature on an attribute
1490        uid is usually going to be v4 as well, since they are not
1491        generally found on v3 keys. */
1492     if (sigversion < pk->version)
1493         sigversion = pk->version;
1494
1495     if( !digest_algo )
1496       {
1497         /* Basically, this means use SHA1 always unless it's a v3 RSA
1498            key making a v3 cert (use MD5), or the user specified
1499            something (use whatever they said), or it's DSA (use the
1500            best match).  They still can't pick an inappropriate hash
1501            for DSA or the signature will fail.  Note that this still
1502            allows the caller of make_keysig_packet to override the
1503            user setting if it must. */
1504
1505         if(opt.cert_digest_algo)
1506           digest_algo=opt.cert_digest_algo;
1507         else if(pksk->pubkey_algo == PUBKEY_ALGO_RSA
1508                 && pk->version<4 && sigversion<4)
1509           digest_algo = DIGEST_ALGO_MD5;
1510         else if(pksk->pubkey_algo == PUBKEY_ALGO_DSA)
1511           digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
1512         else if(pksk->pubkey_algo == PUBKEY_ALGO_ECDSA )
1513           {
1514             if (openpgp_oid_is_ed25519 (pksk->pkey[0]))
1515               digest_algo = DIGEST_ALGO_SHA256;
1516             else
1517               digest_algo = match_dsa_hash
1518                 (ecdsa_qbits_from_Q (gcry_mpi_get_nbits (pksk->pkey[1]))/8);
1519           }
1520         else
1521           digest_algo = DIGEST_ALGO_SHA1;
1522       }
1523
1524     if ( gcry_md_open (&md, digest_algo, 0 ) )
1525       BUG ();
1526
1527     /* Hash the public key certificate. */
1528     hash_public_key( md, pk );
1529
1530     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1531       {
1532         /* hash the subkey binding/backsig/revocation */
1533         hash_public_key( md, subpk );
1534       }
1535     else if( sigclass != 0x1F && sigclass != 0x20 )
1536       {
1537         /* hash the user id */
1538         hash_uid (md, sigversion, uid);
1539       }
1540     /* and make the signature packet */
1541     sig = xmalloc_clear( sizeof *sig );
1542     sig->version = sigversion;
1543     sig->flags.exportable=1;
1544     sig->flags.revocable=1;
1545     keyid_from_pk (pksk, sig->keyid);
1546     sig->pubkey_algo = pksk->pubkey_algo;
1547     sig->digest_algo = digest_algo;
1548     if(timestamp)
1549       sig->timestamp=timestamp;
1550     else
1551       sig->timestamp=make_timestamp();
1552     if(duration)
1553       sig->expiredate=sig->timestamp+duration;
1554     sig->sig_class = sigclass;
1555     if( sig->version >= 4 )
1556       {
1557         build_sig_subpkt_from_sig( sig );
1558         mk_notation_policy_etc (sig, pk, pksk);
1559       }
1560
1561     /* Crucial that the call to mksubpkt comes LAST before the calls
1562        to finalize the sig as that makes it possible for the mksubpkt
1563        function to get a reliable pointer to the subpacket area. */
1564     if( sig->version >= 4 && mksubpkt )
1565         rc = (*mksubpkt)( sig, opaque );
1566
1567     if( !rc ) {
1568         hash_sigversion_to_magic (md, sig);
1569         gcry_md_final (md);
1570
1571         rc = complete_sig (sig, pksk, md, cache_nonce);
1572     }
1573
1574     gcry_md_close (md);
1575     if( rc )
1576         free_seckey_enc( sig );
1577     else
1578         *ret_sig = sig;
1579     return rc;
1580 }
1581
1582
1583
1584 /****************
1585  * Create a new signature packet based on an existing one.
1586  * Only user ID signatures are supported for now.
1587  * PK is the public key to work on.
1588  * PKSK is the key used to make the signature.
1589  *
1590  * TODO: Merge this with make_keysig_packet.
1591  */
1592 int
1593 update_keysig_packet( PKT_signature **ret_sig,
1594                       PKT_signature *orig_sig,
1595                       PKT_public_key *pk,
1596                       PKT_user_id *uid,
1597                       PKT_public_key *subpk,
1598                       PKT_public_key *pksk,
1599                       int (*mksubpkt)(PKT_signature *, void *),
1600                       void *opaque)
1601 {
1602     PKT_signature *sig;
1603     int rc = 0;
1604     int digest_algo;
1605     gcry_md_hd_t md;
1606
1607     if ((!orig_sig || !pk || !pksk)
1608         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1609         || (orig_sig->sig_class == 0x18 && !subpk))
1610       return G10ERR_GENERAL;
1611
1612     if ( opt.cert_digest_algo )
1613       digest_algo = opt.cert_digest_algo;
1614     else
1615       digest_algo = orig_sig->digest_algo;
1616
1617     if ( gcry_md_open (&md, digest_algo, 0 ) )
1618       BUG ();
1619
1620     /* Hash the public key certificate and the user id. */
1621     hash_public_key( md, pk );
1622
1623     if( orig_sig->sig_class == 0x18 )
1624       hash_public_key( md, subpk );
1625     else
1626       hash_uid (md, orig_sig->version, uid);
1627
1628     /* create a new signature packet */
1629     sig = copy_signature (NULL, orig_sig);
1630
1631     sig->digest_algo=digest_algo;
1632
1633     /* We need to create a new timestamp so that new sig expiration
1634        calculations are done correctly... */
1635     sig->timestamp=make_timestamp();
1636
1637     /* ... but we won't make a timestamp earlier than the existing
1638        one. */
1639     while(sig->timestamp<=orig_sig->timestamp)
1640       {
1641         gnupg_sleep (1);
1642         sig->timestamp=make_timestamp();
1643       }
1644
1645     /* Note that already expired sigs will remain expired (with a
1646        duration of 1) since build-packet.c:build_sig_subpkt_from_sig
1647        detects this case. */
1648
1649     if( sig->version >= 4 )
1650       {
1651         /* Put the updated timestamp into the sig.  Note that this
1652            will automagically lower any sig expiration dates to
1653            correctly correspond to the differences in the timestamps
1654            (i.e. the duration will shrink). */
1655         build_sig_subpkt_from_sig( sig );
1656
1657         if (mksubpkt)
1658           rc = (*mksubpkt)(sig, opaque);
1659       }
1660
1661     if (!rc) {
1662         hash_sigversion_to_magic (md, sig);
1663         gcry_md_final (md);
1664
1665         rc = complete_sig (sig, pksk, md, NULL);
1666     }
1667
1668     gcry_md_close (md);
1669     if( rc )
1670         free_seckey_enc (sig);
1671     else
1672         *ret_sig = sig;
1673     return rc;
1674 }