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