Provide a useful pinentry prompt.
[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
231 static gcry_mpi_t
232 mpi_from_sexp (gcry_sexp_t sexp, const char * item)
233 {
234   gcry_sexp_t list;
235   gcry_mpi_t data;
236   
237   list = gcry_sexp_find_token (sexp, item, 0);
238   assert (list);
239   data = gcry_sexp_nth_mpi (list, 1, 0);
240   assert (data);
241   gcry_sexp_release (list);
242   return data;
243 }
244
245
246 static int
247 do_sign (PKT_public_key *pksk, PKT_signature *sig,
248          gcry_md_hd_t md, int mdalgo)
249 {
250   gpg_error_t err;
251   gcry_mpi_t frame;
252   byte *dp;
253
254   if (pksk->timestamp > sig->timestamp )
255     {
256       ulong d = pksk->timestamp - sig->timestamp;
257       log_info (d==1 ? _("key has been created %lu second "
258                          "in future (time warp or clock problem)\n")
259                 : _("key has been created %lu seconds "
260                     "in future (time warp or clock problem)\n"), d );
261       if (!opt.ignore_time_conflict)
262         return gpg_error (GPG_ERR_TIME_CONFLICT);
263     }
264
265   
266   print_pubkey_algo_note (pksk->pubkey_algo);
267
268   if (!mdalgo)
269     mdalgo = gcry_md_get_algo (md);
270
271   print_digest_algo_note (mdalgo);
272   dp = gcry_md_read  (md, mdalgo);
273   sig->digest_algo = mdalgo;
274   sig->digest_start[0] = dp[0];
275   sig->digest_start[1] = dp[1];
276   sig->data[0] = NULL;
277   sig->data[1] = NULL;
278
279 #warning fixme: Use the agent for the card
280 /*     if (pksk->is_protected && pksk->protect.s2k.mode == 1002)  */
281 /*       {  */
282 /* #ifdef ENABLE_CARD_SUPPORT */
283 /*         unsigned char *rbuf; */
284 /*         size_t rbuflen; */
285 /*         char *snbuf; */
286         
287 /*         snbuf = serialno_and_fpr_from_sk (sk->protect.iv, */
288 /*                                           sk->protect.ivlen, sk); */
289 /*         rc = agent_scd_pksign (snbuf, digest_algo, */
290 /*                                gcry_md_read (md, digest_algo), */
291 /*                                gcry_md_get_algo_dlen (digest_algo), */
292 /*                                &rbuf, &rbuflen); */
293 /*         xfree (snbuf); */
294 /*         if (!rc) */
295 /*           { */
296 /*             if (gcry_mpi_scan (&sig->data[0], GCRYMPI_FMT_USG, */
297 /*                                rbuf, rbuflen, NULL)) */
298 /*               BUG (); */
299 /*             xfree (rbuf); */
300 /*           } */
301 /* #else */
302 /*         return gpg_error (GPG_ERR_NOT_SUPPORTED); */
303 /* #endif /\* ENABLE_CARD_SUPPORT *\/ */
304 /*       } */
305 /*     else  */
306   if (1)
307     {
308       char *hexgrip;
309       
310       err = hexkeygrip_from_pk (pksk, &hexgrip);
311       if (!err)
312         {
313           char *desc;
314           gcry_sexp_t s_sigval;
315           
316           desc = gpg_format_keydesc (pksk, 1);
317           err = agent_pksign (NULL/*ctrl*/, hexgrip, desc, 
318                               dp, gcry_md_get_algo_dlen (mdalgo), mdalgo,
319                               &s_sigval);
320           xfree (desc);
321      
322           if (err)
323             ;
324           else if (pksk->pubkey_algo == GCRY_PK_RSA
325                    || pksk->pubkey_algo == GCRY_PK_RSA_S)
326             sig->data[0] = mpi_from_sexp (s_sigval, "s");
327           else
328             {
329               sig->data[0] = mpi_from_sexp (s_sigval, "r");
330               sig->data[1] = mpi_from_sexp (s_sigval, "s");
331             }
332       
333           gcry_sexp_release (s_sigval);
334         }
335       xfree (hexgrip);
336     }
337
338   /* Check that the signature verification worked and nothing is
339    * fooling us e.g. by a bug in the signature create code or by
340    * deliberately introduced faults.  */
341   if (!err && !opt.no_sig_create_check)
342     {
343       PKT_public_key *pk = xmalloc_clear (sizeof *pk);
344
345       if (get_pubkey (pk, sig->keyid ))
346         err = gpg_error (GPG_ERR_NO_PUBKEY);
347       else 
348         {
349           frame = encode_md_value (pk, md, sig->digest_algo );
350           if (!frame)
351             err = gpg_error (GPG_ERR_GENERAL);
352           else
353             err = pk_verify (pk->pubkey_algo, frame, sig->data, pk->pkey);
354           gcry_mpi_release (frame);
355         }
356       if (err)
357         log_error (_("checking created signature failed: %s\n"),
358                    g10_errstr (err));
359       free_public_key (pk);
360     }
361
362   if (err)
363     log_error (_("signing failed: %s\n"), g10_errstr (err));
364   else 
365     {
366       if (opt.verbose)
367         {
368           char *ustr = get_user_id_string_native (sig->keyid);
369           log_info (_("%s/%s signature from: \"%s\"\n"),
370                     gcry_pk_algo_name (pksk->pubkey_algo),
371                     gcry_md_algo_name (sig->digest_algo),
372                     ustr);
373           xfree (ustr);
374         }
375     }
376   return err;
377 }
378
379
380 int
381 complete_sig (PKT_signature *sig, PKT_public_key *pksk, gcry_md_hd_t md)
382 {
383   int rc;
384
385   /* if (!(rc = check_secret_key (pksk, 0))) */
386     rc = do_sign (pksk, sig, md, 0);
387   return rc;
388 }
389
390
391
392 static int
393 match_dsa_hash (unsigned int qbytes)
394 {
395   if (qbytes <= 20)
396     return DIGEST_ALGO_SHA1;
397
398   if (qbytes <= 28)
399     return DIGEST_ALGO_SHA224;
400
401   if (qbytes <= 32)
402     return DIGEST_ALGO_SHA256;
403
404   if (qbytes <= 48)
405     return DIGEST_ALGO_SHA384;
406
407   if (qbytes <= 64)
408     return DIGEST_ALGO_SHA512;
409
410   return DEFAULT_DIGEST_ALGO;
411   /* DEFAULT_DIGEST_ALGO will certainly fail, but it's the best wrong
412      answer we have if a digest larger than 512 bits is requested.  */
413 }
414
415
416 /*
417   First try --digest-algo.  If that isn't set, see if the recipient
418   has a preferred algorithm (which is also filtered through
419   --preferred-digest-prefs).  If we're making a signature without a
420   particular recipient (i.e. signing, rather than signing+encrypting)
421   then take the first algorithm in --preferred-digest-prefs that is
422   usable for the pubkey algorithm.  If --preferred-digest-prefs isn't
423   set, then take the OpenPGP default (i.e. SHA-1).
424
425   Possible improvement: Use the highest-ranked usable algorithm from
426   the signing key prefs either before or after using the personal
427   list?
428 */
429 static int
430 hash_for (PKT_public_key *pk)
431 {
432   if (opt.def_digest_algo)
433     {
434       return opt.def_digest_algo;
435     }
436   else if (recipient_digest_algo)
437     {
438       return recipient_digest_algo;
439     }
440   else if (pk->pubkey_algo == PUBKEY_ALGO_DSA)
441     {
442       unsigned int qbytes = gcry_mpi_get_nbits (pk->pkey[1]) / 8;
443
444       /* It's a DSA key, so find a hash that is the same size as q or
445          larger.  If q is 160, assume it is an old DSA key and use a
446          160-bit hash unless --enable-dsa2 is set, in which case act
447          like a new DSA key that just happens to have a 160-bit q
448          (i.e. allow truncation).  If q is not 160, by definition it
449          must be a new DSA key. */
450
451       if (opt.personal_digest_prefs)
452         {
453           prefitem_t *prefs;
454
455           if (qbytes != 20 || opt.flags.dsa2)
456             {
457               for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
458                 if (gcry_md_get_algo_dlen (prefs->value) >= qbytes)
459                   return prefs->value;
460             }
461           else
462             {
463               for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
464                 if (gcry_md_get_algo_dlen (prefs->value) == qbytes)
465                   return prefs->value;
466             }
467         }
468
469       return match_dsa_hash(qbytes);
470     }
471   else if (0 
472            /* FIXME: call agent sk->is_protected && sk->protect.s2k.mode == 1002
473            && sk->protect.ivlen == 16
474            && !memcmp (sk->protect.iv, "\xD2\x76\x00\x01\x24\x01\x01", 7)*/)
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)
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));
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( 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 && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
824       goto leave;
825
826     /* prepare iobufs */
827     if( multifile )  /* have list of filenames */
828         inp = NULL; /* we do it later */
829     else {
830       inp = iobuf_open(fname);
831       if (inp && is_secured_file (iobuf_get_fd (inp)))
832         {
833           iobuf_close (inp);
834           inp = NULL;
835           gpg_err_set_errno (EPERM);
836         }
837       if( !inp ) 
838         {
839           rc = gpg_error_from_syserror ();
840           log_error (_("can't open `%s': %s\n"), fname? fname: "[stdin]",
841                      strerror(errno) );
842           goto leave;
843         }
844
845         handle_progress (pfx, inp, fname);
846     }
847
848     if( outfile ) {
849         if (is_secured_filename ( outfile )) {
850             out = NULL;
851             gpg_err_set_errno (EPERM);
852         }
853         else
854             out = iobuf_create( outfile );
855         if( !out )
856           {
857             rc = gpg_error_from_syserror ();
858             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
859             goto leave;
860           }
861         else if( opt.verbose )
862             log_info(_("writing to `%s'\n"), outfile );
863     }
864     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname,
865                                  opt.armor? 1: detached? 2:0, &out )))
866         goto leave;
867
868     /* prepare to calculate the MD over the input */
869     if( opt.textmode && !outfile && !multifile )
870       {
871         memset( &tfx, 0, sizeof tfx);
872         iobuf_push_filter( inp, text_filter, &tfx );
873       }
874
875     if ( gcry_md_open (&mfx.md, 0, 0) )
876       BUG ();
877     if (DBG_HASHING)
878       gcry_md_start_debug (mfx.md, "sign");
879
880     /* If we're encrypting and signing, it is reasonable to pick the
881        hash algorithm to use out of the recepient key prefs.  This is
882        best effort only, as in a DSA2 and smartcard world there are
883        cases where we cannot please everyone with a single hash (DSA2
884        wants >160 and smartcards want =160).  In the future this could
885        be more complex with different hashes for each sk, but the
886        current design requires a single hash for all SKs. */
887     if(pk_list)
888       {
889         if(opt.def_digest_algo)
890           {
891             if(!opt.expert &&
892                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
893                                       opt.def_digest_algo,
894                                       NULL)!=opt.def_digest_algo)
895           log_info(_("WARNING: forcing digest algorithm %s (%d)"
896                      " violates recipient preferences\n"),
897                    gcry_md_algo_name (opt.def_digest_algo),
898                    opt.def_digest_algo );
899           }
900         else
901           {
902             int algo, smartcard=0;
903             union pref_hint hint;
904
905             hint.digest_length = 0;
906
907             /* Of course, if the recipient asks for something
908                unreasonable (like the wrong hash for a DSA key) then
909                don't do it.  Check all sk's - if any are DSA or live
910                on a smartcard, then the hash has restrictions and we
911                may not be able to give the recipient what they want.
912                For DSA, pass a hint for the largest q we have.  Note
913                that this means that a q>160 key will override a q=160
914                key and force the use of truncation for the q=160 key.
915                The alternative would be to ignore the recipient prefs
916                completely and get a different hash for each DSA key in
917                hash_for().  The override behavior here is more or less
918                reasonable as it is under the control of the user which
919                keys they sign with for a given message and the fact
920                that the message with multiple signatures won't be
921                usable on an implementation that doesn't understand
922                DSA2 anyway. */
923
924             for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
925               {
926                 if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_DSA)
927                   {
928                     int temp_hashlen = gcry_mpi_get_nbits
929                       (sk_rover->pk->pkey[1])+7/8;
930
931                     /* Pick a hash that is large enough for our
932                        largest q */
933
934                     if (hint.digest_length<temp_hashlen)
935                       hint.digest_length=temp_hashlen;
936                   }
937                 /* FIXME: need toall gpg-agent */
938                 /* else if (sk_rover->pk->is_protected */
939                 /*          && sk_rover->pk->protect.s2k.mode == 1002) */
940                 /*   smartcard = 1;  */
941               }
942
943             /* Current smartcards only do 160-bit hashes.  If we have
944                to have a >160-bit hash, then we can't use the
945                recipient prefs as we'd need both =160 and >160 at the
946                same time and recipient prefs currently require a
947                single hash for all signatures.  All this may well have
948                to change as the cards add algorithms. */
949
950             if (!smartcard || (smartcard && hint.digest_length==20))
951               if ( (algo=
952                    select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint)) > 0)
953                 recipient_digest_algo=algo;
954           }
955       }
956
957     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
958       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
959
960     if( !multifile )
961         iobuf_push_filter( inp, md_filter, &mfx );
962
963     if( detached && !encryptflag && !RFC1991 )
964         afx->what = 2;
965
966     if( opt.armor && !outfile  )
967         push_armor_filter (afx, out);
968
969     if( encryptflag ) {
970         efx.pk_list = pk_list;
971         /* fixme: set efx.cfx.datalen if known */
972         iobuf_push_filter( out, encrypt_filter, &efx );
973     }
974
975     if( opt.compress_algo && !outfile && ( !detached || opt.compress_sigs) )
976       {
977         int compr_algo=opt.compress_algo;
978
979         /* If not forced by user */
980         if(compr_algo==-1)
981           {
982             /* If we're not encrypting, then select_algo_from_prefs
983                will fail and we'll end up with the default.  If we are
984                encrypting, select_algo_from_prefs cannot fail since
985                there is an assumed preference for uncompressed data.
986                Still, if it did fail, we'll also end up with the
987                default. */
988  
989             if((compr_algo=
990                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
991               compr_algo=default_compress_algo();
992           }
993         else if(!opt.expert && pk_list
994                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
995                                           compr_algo,NULL)!=compr_algo)
996           log_info(_("WARNING: forcing compression algorithm %s (%d)"
997                      " violates recipient preferences\n"),
998                    compress_algo_to_string(compr_algo),compr_algo);
999
1000         /* algo 0 means no compression */
1001         if( compr_algo )
1002           push_compress_filter(out,&zfx,compr_algo);
1003       }
1004
1005     /* Write the one-pass signature packets if needed */
1006     if (!detached && !RFC1991) {
1007         rc = write_onepass_sig_packets (sk_list, out,
1008                                         opt.textmode && !outfile ? 0x01:0x00);
1009         if (rc)
1010             goto leave;
1011     }
1012
1013     write_status_begin_signing (mfx.md);
1014
1015     /* Setup the inner packet. */
1016     if( detached ) {
1017         if( multifile ) {
1018             strlist_t sl;
1019
1020             if( opt.verbose )
1021                 log_info(_("signing:") );
1022             /* must walk reverse trough this list */
1023             for( sl = strlist_last(filenames); sl;
1024                         sl = strlist_prev( filenames, sl ) ) {
1025                 inp = iobuf_open(sl->d);
1026                 if (inp && is_secured_file (iobuf_get_fd (inp)))
1027                   {
1028                     iobuf_close (inp);
1029                     inp = NULL;
1030                     gpg_err_set_errno (EPERM);
1031                   }
1032                 if( !inp )
1033                   {
1034                     rc = gpg_error_from_syserror ();
1035                     log_error(_("can't open `%s': %s\n"),
1036                               sl->d,strerror(errno));
1037                     goto leave;
1038                   }
1039                 handle_progress (pfx, inp, sl->d);
1040                 if( opt.verbose )
1041                     fprintf(stderr, " `%s'", sl->d );
1042                 if(opt.textmode)
1043                   {
1044                     memset( &tfx, 0, sizeof tfx);
1045                     iobuf_push_filter( inp, text_filter, &tfx );
1046                   }
1047                 iobuf_push_filter( inp, md_filter, &mfx );
1048                 while( iobuf_get(inp) != -1 )
1049                     ;
1050                 iobuf_close(inp); inp = NULL;
1051             }
1052             if( opt.verbose )
1053                 putc( '\n', stderr );
1054         }
1055         else {
1056             /* read, so that the filter can calculate the digest */
1057             while( iobuf_get(inp) != -1 )
1058                 ;
1059         }
1060     }
1061     else {
1062         rc = write_plaintext_packet (out, inp, fname,
1063                                      opt.textmode && !outfile ? 't':'b');
1064     }
1065
1066     /* catch errors from above */
1067     if (rc)
1068         goto leave;
1069
1070     /* write the signatures */
1071     rc = write_signature_packets (sk_list, out, mfx.md,
1072                                   opt.textmode && !outfile? 0x01 : 0x00,
1073                                   0, duration, detached ? 'D':'S');
1074     if( rc )
1075         goto leave;
1076
1077
1078   leave:
1079     if( rc )
1080         iobuf_cancel(out);
1081     else {
1082         iobuf_close(out);
1083         if (encryptflag)
1084             write_status( STATUS_END_ENCRYPTION );
1085     }
1086     iobuf_close(inp);
1087     gcry_md_close ( mfx.md );
1088     release_sk_list( sk_list );
1089     release_pk_list( pk_list );
1090     recipient_digest_algo=0;
1091     release_progress_context (pfx);
1092     release_armor_context (afx);
1093     return rc;
1094 }
1095
1096
1097
1098 /****************
1099  * make a clear signature. note that opt.armor is not needed
1100  */
1101 int
1102 clearsign_file( const char *fname, strlist_t locusr, const char *outfile )
1103 {
1104     armor_filter_context_t *afx;
1105     progress_filter_context_t *pfx;
1106     gcry_md_hd_t textmd = NULL;
1107     IOBUF inp = NULL, out = NULL;
1108     PACKET pkt;
1109     int rc = 0;
1110     SK_LIST sk_list = NULL;
1111     SK_LIST sk_rover = NULL;
1112     int old_style = RFC1991;
1113     int only_md5 = 0;
1114     u32 duration=0;
1115
1116     pfx = new_progress_context ();
1117     afx = new_armor_context ();
1118     init_packet( &pkt );
1119
1120     if(!opt.force_v3_sigs && !RFC1991)
1121       {
1122         if(opt.ask_sig_expire && !opt.batch)
1123           duration=ask_expire_interval(1,opt.def_sig_expire);
1124         else
1125           duration=parse_expire_string(opt.def_sig_expire);
1126       }
1127
1128     /* Note: In the old non-agent version the following call used to
1129        unprotect the secret key.  This is now done on demand by the agent.  */
1130     if( (rc=build_sk_list( locusr, &sk_list, PUBKEY_USAGE_SIG )) )
1131         goto leave;
1132
1133     if( !old_style && !duration )
1134         old_style = only_old_style( sk_list );
1135
1136     if(PGP2 && !only_old_style(sk_list))
1137       {
1138         log_info(_("you can only clearsign with PGP 2.x style keys "
1139                    "while in --pgp2 mode\n"));
1140         compliance_failure();
1141       }
1142
1143     /* prepare iobufs */
1144     inp = iobuf_open(fname);
1145     if (inp && is_secured_file (iobuf_get_fd (inp)))
1146       {
1147         iobuf_close (inp);
1148         inp = NULL;
1149         gpg_err_set_errno (EPERM);
1150       }
1151     if( !inp ) {
1152         rc = gpg_error_from_syserror ();
1153         log_error (_("can't open `%s': %s\n"), 
1154                    fname? fname: "[stdin]", strerror(errno) );
1155         goto leave;
1156     }
1157     handle_progress (pfx, inp, fname);
1158
1159     if( outfile ) {
1160         if (is_secured_filename (outfile) ) {
1161             outfile = NULL;
1162             gpg_err_set_errno (EPERM);
1163         }
1164         else 
1165             out = iobuf_create( outfile );
1166         if( !out )
1167           {
1168             rc = gpg_error_from_syserror ();
1169             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
1170             goto leave;
1171           }
1172         else if( opt.verbose )
1173             log_info(_("writing to `%s'\n"), outfile );
1174     }
1175     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname, 1, &out )) )
1176         goto leave;
1177
1178     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1179
1180     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1181       {
1182         if (hash_for (sk_rover->pk) == DIGEST_ALGO_MD5)
1183           only_md5 = 1;
1184         else 
1185           {
1186             only_md5 = 0;
1187             break;
1188           }
1189       }
1190
1191     if( !(old_style && only_md5) ) {
1192         const char *s;
1193         int any = 0;
1194         byte hashs_seen[256];
1195
1196         memset( hashs_seen, 0, sizeof hashs_seen );
1197         iobuf_writestr(out, "Hash: " );
1198         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1199             int i = hash_for (sk_rover->pk);
1200
1201             if( !hashs_seen[ i & 0xff ] ) {
1202                 s = gcry_md_algo_name ( i );
1203                 if( s ) {
1204                     hashs_seen[ i & 0xff ] = 1;
1205                     if( any )
1206                         iobuf_put(out, ',' );
1207                     iobuf_writestr(out, s );
1208                     any = 1;
1209                 }
1210             }
1211         }
1212         assert(any);
1213         iobuf_writestr(out, LF );
1214     }
1215
1216     if( opt.not_dash_escaped )
1217       iobuf_writestr( out,
1218                   "NotDashEscaped: You need GnuPG to verify this message" LF );
1219     iobuf_writestr(out, LF );
1220
1221     if ( gcry_md_open (&textmd, 0, 0) )
1222       BUG ();
1223     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1224       gcry_md_enable (textmd, hash_for(sk_rover->pk));
1225
1226     if ( DBG_HASHING )
1227       gcry_md_start_debug ( textmd, "clearsign" );
1228
1229     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
1230                         opt.escape_from, (old_style && only_md5) );
1231     /* fixme: check for read errors */
1232
1233     /* now write the armor */
1234     afx->what = 2;
1235     push_armor_filter (afx, out);
1236
1237     /* write the signatures */
1238     rc=write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C');
1239     if( rc )
1240         goto leave;
1241
1242   leave:
1243     if( rc )
1244         iobuf_cancel(out);
1245     else
1246         iobuf_close(out);
1247     iobuf_close(inp);
1248     gcry_md_close ( textmd );
1249     release_sk_list( sk_list );
1250     release_progress_context (pfx);
1251     release_armor_context (afx); 
1252     return rc;
1253 }
1254
1255 /*
1256  * Sign and conventionally encrypt the given file.
1257  * FIXME: Far too much code is duplicated - revamp the whole file.
1258  */
1259 int
1260 sign_symencrypt_file (const char *fname, strlist_t locusr)
1261 {
1262     armor_filter_context_t *afx;
1263     progress_filter_context_t *pfx;
1264     compress_filter_context_t zfx;
1265     md_filter_context_t mfx;
1266     text_filter_context_t tfx;
1267     cipher_filter_context_t cfx;
1268     IOBUF inp = NULL, out = NULL;
1269     PACKET pkt;
1270     STRING2KEY *s2k = NULL;
1271     int rc = 0;
1272     SK_LIST sk_list = NULL;
1273     SK_LIST sk_rover = NULL;
1274     int algo;
1275     u32 duration=0;
1276     int canceled;
1277
1278     pfx = new_progress_context ();
1279     afx = new_armor_context ();
1280     memset( &zfx, 0, sizeof zfx);
1281     memset( &mfx, 0, sizeof mfx);
1282     memset( &tfx, 0, sizeof tfx);
1283     memset( &cfx, 0, sizeof cfx);
1284     init_packet( &pkt );
1285
1286     if(!opt.force_v3_sigs && !RFC1991)
1287       {
1288         if(opt.ask_sig_expire && !opt.batch)
1289           duration=ask_expire_interval(1,opt.def_sig_expire);
1290         else
1291           duration=parse_expire_string(opt.def_sig_expire);
1292       }
1293
1294     /* Note: In the old non-agent version the following call used to
1295        unprotect the secret key.  This is now done on demand by the agent.  */
1296     rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG);
1297     if (rc) 
1298         goto leave;
1299
1300     /* prepare iobufs */
1301     inp = iobuf_open(fname);
1302     if (inp && is_secured_file (iobuf_get_fd (inp)))
1303       {
1304         iobuf_close (inp);
1305         inp = NULL;
1306         gpg_err_set_errno (EPERM);
1307       }
1308     if( !inp ) {
1309         rc = gpg_error_from_syserror ();
1310         log_error (_("can't open `%s': %s\n"), 
1311                    fname? fname: "[stdin]", strerror(errno) );
1312         goto leave;
1313     }
1314     handle_progress (pfx, inp, fname);
1315
1316     /* prepare key */
1317     s2k = xmalloc_clear( sizeof *s2k );
1318     s2k->mode = RFC1991? 0:opt.s2k_mode;
1319     s2k->hash_algo = S2K_DIGEST_ALGO;
1320
1321     algo = default_cipher_algo();
1322     if (!opt.quiet || !opt.batch)
1323         log_info (_("%s encryption will be used\n"),
1324                   openpgp_cipher_algo_name (algo) );
1325     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, &canceled);
1326
1327     if (!cfx.dek || !cfx.dek->keylen) {
1328         rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
1329         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1330         goto leave;
1331     }
1332
1333     /* We have no way to tell if the recipient can handle messages
1334        with an MDC, so this defaults to no.  Perhaps in a few years,
1335        this can be defaulted to yes.  Note that like regular
1336        encrypting, --force-mdc overrides --disable-mdc. */
1337     if(opt.force_mdc)
1338       cfx.dek->use_mdc=1;
1339
1340     /* now create the outfile */
1341     rc = open_outfile (GNUPG_INVALID_FD, fname, opt.armor? 1:0, &out);
1342     if (rc)
1343         goto leave;
1344
1345     /* prepare to calculate the MD over the input */
1346     if (opt.textmode)
1347         iobuf_push_filter (inp, text_filter, &tfx);
1348     if ( gcry_md_open (&mfx.md, 0, 0) )
1349       BUG ();
1350     if ( DBG_HASHING )
1351       gcry_md_start_debug (mfx.md, "symc-sign");
1352
1353     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1354       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
1355
1356     iobuf_push_filter (inp, md_filter, &mfx);
1357
1358     /* Push armor output filter */
1359     if (opt.armor)
1360         push_armor_filter (afx, out);
1361
1362     /* Write the symmetric key packet */
1363     /*(current filters: armor)*/
1364     if (!RFC1991) {
1365         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1366         enc->version = 4;
1367         enc->cipher_algo = cfx.dek->algo;
1368         enc->s2k = *s2k;
1369         pkt.pkttype = PKT_SYMKEY_ENC;
1370         pkt.pkt.symkey_enc = enc;
1371         if( (rc = build_packet( out, &pkt )) )
1372             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1373         xfree(enc);
1374     }
1375
1376     /* Push the encryption filter */
1377     iobuf_push_filter( out, cipher_filter, &cfx );
1378
1379     /* Push the compress filter */
1380     if (default_compress_algo())
1381       push_compress_filter(out,&zfx,default_compress_algo());
1382
1383     /* Write the one-pass signature packets */
1384     /*(current filters: zip - encrypt - armor)*/
1385     if (!RFC1991) {
1386         rc = write_onepass_sig_packets (sk_list, out,
1387                                         opt.textmode? 0x01:0x00);
1388         if (rc)
1389             goto leave;
1390     }
1391
1392     write_status_begin_signing (mfx.md);
1393
1394     /* Pipe data through all filters; i.e. write the signed stuff */
1395     /*(current filters: zip - encrypt - armor)*/
1396     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1397     if (rc)
1398         goto leave;
1399     
1400     /* Write the signatures */
1401     /*(current filters: zip - encrypt - armor)*/
1402     rc = write_signature_packets (sk_list, out, mfx.md,
1403                                   opt.textmode? 0x01 : 0x00,
1404                                   0, duration, 'S');
1405     if( rc )
1406         goto leave;
1407
1408
1409   leave:
1410     if( rc )
1411         iobuf_cancel(out);
1412     else {
1413         iobuf_close(out);
1414         write_status( STATUS_END_ENCRYPTION );
1415     }
1416     iobuf_close(inp);
1417     release_sk_list( sk_list );
1418     gcry_md_close( mfx.md );
1419     xfree(cfx.dek);
1420     xfree(s2k);
1421     release_progress_context (pfx);
1422     release_armor_context (afx);
1423     return rc;
1424 }
1425
1426
1427 /****************
1428  * Create a signature packet for the given public key certificate and
1429  * the user id and return it in ret_sig. User signature class SIGCLASS
1430  * user-id is not used (and may be NULL if sigclass is 0x20) If
1431  * DIGEST_ALGO is 0 the function selects an appropriate one.
1432  * SIGVERSION gives the minimal required signature packet version;
1433  * this is needed so that special properties like local sign are not
1434  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1435  * the timestamp to use for the signature. 0 means "now" */
1436 int
1437 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1438                     PKT_user_id *uid, PKT_public_key *subpk,
1439                     PKT_public_key *pksk,
1440                     int sigclass, int digest_algo,
1441                     int sigversion, u32 timestamp, u32 duration,
1442                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
1443                    )
1444 {
1445     PKT_signature *sig;
1446     int rc=0;
1447     gcry_md_hd_t md;
1448
1449     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1450             || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1451             || sigclass == 0x30 || sigclass == 0x28 );
1452
1453     if (opt.force_v4_certs)
1454         sigversion = 4;
1455
1456     if (sigversion < pksk->version)
1457         sigversion = pksk->version;
1458
1459     /* If you are making a signature on a v4 key using your v3 key, it
1460        doesn't make sense to generate a v3 sig.  After all, no v3-only
1461        PGP implementation could understand the v4 key in the first
1462        place.  Note that this implies that a signature on an attribute
1463        uid is usually going to be v4 as well, since they are not
1464        generally found on v3 keys. */
1465     if (sigversion < pk->version)
1466         sigversion = pk->version;
1467
1468     if( !digest_algo )
1469       {
1470         /* Basically, this means use SHA1 always unless it's a v3 RSA
1471            key making a v3 cert (use MD5), or the user specified
1472            something (use whatever they said), or it's DSA (use the
1473            best match).  They still can't pick an inappropriate hash
1474            for DSA or the signature will fail.  Note that this still
1475            allows the caller of make_keysig_packet to override the
1476            user setting if it must. */
1477
1478         if(opt.cert_digest_algo)
1479           digest_algo=opt.cert_digest_algo;
1480         else if(pksk->pubkey_algo==PUBKEY_ALGO_RSA
1481                 && pk->version<4 && sigversion<4)
1482           digest_algo = DIGEST_ALGO_MD5;
1483         else if(pksk->pubkey_algo==PUBKEY_ALGO_DSA)
1484           digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
1485         else
1486           digest_algo = DIGEST_ALGO_SHA1;
1487       }
1488
1489     if ( gcry_md_open (&md, digest_algo, 0 ) )
1490       BUG ();
1491
1492     /* Hash the public key certificate. */
1493     hash_public_key( md, pk );
1494
1495     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1496       {
1497         /* hash the subkey binding/backsig/revocation */
1498         hash_public_key( md, subpk );
1499       }
1500     else if( sigclass != 0x1F && sigclass != 0x20 )
1501       {
1502         /* hash the user id */
1503         hash_uid (md, sigversion, uid);
1504       }
1505     /* and make the signature packet */
1506     sig = xmalloc_clear( sizeof *sig );
1507     sig->version = sigversion;
1508     sig->flags.exportable=1;
1509     sig->flags.revocable=1;
1510     keyid_from_pk (pksk, sig->keyid);
1511     sig->pubkey_algo = pksk->pubkey_algo;
1512     sig->digest_algo = digest_algo;
1513     if(timestamp)
1514       sig->timestamp=timestamp;
1515     else
1516       sig->timestamp=make_timestamp();
1517     if(duration)
1518       sig->expiredate=sig->timestamp+duration;
1519     sig->sig_class = sigclass;
1520     if( sig->version >= 4 )
1521       {
1522         build_sig_subpkt_from_sig( sig );
1523         mk_notation_policy_etc (sig, pk, pksk);
1524       }
1525
1526     /* Crucial that the call to mksubpkt comes LAST before the calls
1527        to finalize the sig as that makes it possible for the mksubpkt
1528        function to get a reliable pointer to the subpacket area. */
1529     if( sig->version >= 4 && mksubpkt )
1530         rc = (*mksubpkt)( sig, opaque );
1531
1532     if( !rc ) {
1533         hash_sigversion_to_magic (md, sig);
1534         gcry_md_final (md);
1535
1536         rc = complete_sig (sig, pksk, md);
1537     }
1538
1539     gcry_md_close (md);
1540     if( rc )
1541         free_seckey_enc( sig );
1542     else
1543         *ret_sig = sig;
1544     return rc;
1545 }
1546
1547
1548
1549 /****************
1550  * Create a new signature packet based on an existing one.
1551  * Only user ID signatures are supported for now.
1552  * PK is the public key to work on.
1553  * PKSK is the key used to make the signature.
1554  *
1555  * TODO: Merge this with make_keysig_packet.
1556  */
1557 int
1558 update_keysig_packet( PKT_signature **ret_sig,
1559                       PKT_signature *orig_sig,
1560                       PKT_public_key *pk,
1561                       PKT_user_id *uid, 
1562                       PKT_public_key *subpk,
1563                       PKT_public_key *pksk,
1564                       int (*mksubpkt)(PKT_signature *, void *),
1565                       void *opaque )
1566 {
1567     PKT_signature *sig;
1568     int rc=0;
1569     gcry_md_hd_t md;
1570
1571     if ((!orig_sig || !pk || !pksk)
1572         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1573         || (orig_sig->sig_class == 0x18 && !subpk))
1574       return G10ERR_GENERAL;
1575
1576     if ( gcry_md_open (&md, orig_sig->digest_algo, 0 ) )
1577       BUG ();
1578
1579     /* Hash the public key certificate and the user id. */
1580     hash_public_key( md, pk );
1581
1582     if( orig_sig->sig_class == 0x18 )
1583       hash_public_key( md, subpk );
1584     else
1585       hash_uid (md, orig_sig->version, uid);
1586
1587     /* create a new signature packet */
1588     sig = copy_signature (NULL, orig_sig);
1589  
1590     /* We need to create a new timestamp so that new sig expiration
1591        calculations are done correctly... */
1592     sig->timestamp=make_timestamp();
1593
1594     /* ... but we won't make a timestamp earlier than the existing
1595        one. */
1596     while(sig->timestamp<=orig_sig->timestamp)
1597       {
1598         gnupg_sleep (1);
1599         sig->timestamp=make_timestamp();
1600       }
1601
1602     /* Note that already expired sigs will remain expired (with a
1603        duration of 1) since build-packet.c:build_sig_subpkt_from_sig
1604        detects this case. */
1605
1606     if( sig->version >= 4 )
1607       {
1608         /* Put the updated timestamp into the sig.  Note that this
1609            will automagically lower any sig expiration dates to
1610            correctly correspond to the differences in the timestamps
1611            (i.e. the duration will shrink). */
1612         build_sig_subpkt_from_sig( sig );
1613
1614         if (mksubpkt)
1615           rc = (*mksubpkt)(sig, opaque);
1616       }
1617
1618     if (!rc) {
1619         hash_sigversion_to_magic (md, sig);
1620         gcry_md_final (md);
1621
1622         rc = complete_sig (sig, pksk, md);
1623     }
1624
1625     gcry_md_close (md);
1626     if( rc )
1627         free_seckey_enc (sig);
1628     else
1629         *ret_sig = sig;
1630     return rc;
1631 }