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