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