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