gpg: Add pinentry-mode feature.
[gnupg.git] / g10 / sign.c
1 /* sign.c - sign data
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2007, 2010, 2012 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "gpg.h"
29 #include "options.h"
30 #include "packet.h"
31 #include "status.h"
32 #include "iobuf.h"
33 #include "keydb.h"
34 #include "util.h"
35 #include "main.h"
36 #include "filter.h"
37 #include "ttyio.h"
38 #include "trustdb.h"
39 #include "status.h"
40 #include "i18n.h"
41 #include "pkglue.h"
42 #include "sysutils.h"
43 #include "call-agent.h"
44
45
46 #ifdef HAVE_DOSISH_SYSTEM
47 #define LF "\r\n"
48 #else
49 #define LF "\n"
50 #endif
51
52 static int recipient_digest_algo=0;
53
54 /****************
55  * Create notations and other stuff.  It is assumed that the stings in
56  * STRLIST are already checked to contain only printable data and have
57  * a valid NAME=VALUE format.
58  */
59 static void
60 mk_notation_policy_etc (PKT_signature *sig,
61                         PKT_public_key *pk, PKT_public_key *pksk)
62 {
63     const char *string;
64     char *s=NULL;
65     strlist_t pu=NULL;
66     struct notation *nd=NULL;
67     struct expando_args args;
68
69     assert(sig->version>=4);
70
71     memset(&args,0,sizeof(args));
72     args.pk=pk;
73     args.pksk=pksk;
74
75     /* notation data */
76     if(IS_SIG(sig) && opt.sig_notations)
77       nd=opt.sig_notations;
78     else if( IS_CERT(sig) && opt.cert_notations )
79       nd=opt.cert_notations;
80
81     if(nd)
82       {
83         struct notation *i;
84
85         for(i=nd;i;i=i->next)
86           {
87             i->altvalue=pct_expando(i->value,&args);
88             if(!i->altvalue)
89               log_error(_("WARNING: unable to %%-expand notation "
90                           "(too large).  Using unexpanded.\n"));
91           }
92
93         keygen_add_notations(sig,nd);
94
95         for(i=nd;i;i=i->next)
96           {
97             xfree(i->altvalue);
98             i->altvalue=NULL;
99           }
100       }
101
102     /* set policy URL */
103     if( IS_SIG(sig) && opt.sig_policy_url )
104       pu=opt.sig_policy_url;
105     else if( IS_CERT(sig) && opt.cert_policy_url )
106       pu=opt.cert_policy_url;
107
108     for(;pu;pu=pu->next)
109       {
110         string = pu->d;
111
112         s=pct_expando(string,&args);
113         if(!s)
114           {
115             log_error(_("WARNING: unable to %%-expand policy URL "
116                         "(too large).  Using unexpanded.\n"));
117             s=xstrdup(string);
118           }
119
120         build_sig_subpkt(sig,SIGSUBPKT_POLICY|
121                          ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0),
122                          s,strlen(s));
123
124         xfree(s);
125       }
126
127     /* preferred keyserver URL */
128     if( IS_SIG(sig) && opt.sig_keyserver_url )
129       pu=opt.sig_keyserver_url;
130
131     for(;pu;pu=pu->next)
132       {
133         string = pu->d;
134
135         s=pct_expando(string,&args);
136         if(!s)
137           {
138             log_error(_("WARNING: unable to %%-expand preferred keyserver URL"
139                         " (too large).  Using unexpanded.\n"));
140             s=xstrdup(string);
141           }
142
143         build_sig_subpkt(sig,SIGSUBPKT_PREF_KS|
144                          ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0),
145                          s,strlen(s));
146
147         xfree(s);
148       }
149 }
150
151
152 /*
153  * Helper to hash a user ID packet.
154  */
155 static void
156 hash_uid (gcry_md_hd_t md, int sigversion, const PKT_user_id *uid)
157 {
158     if ( sigversion >= 4 ) {
159         byte buf[5];
160
161         if(uid->attrib_data) {
162           buf[0] = 0xd1;                   /* indicates an attribute packet */
163           buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
164           buf[2] = uid->attrib_len >> 16;
165           buf[3] = uid->attrib_len >>  8;
166           buf[4] = uid->attrib_len;
167         }
168         else {
169           buf[0] = 0xb4;            /* indicates a userid packet */
170           buf[1] = uid->len >> 24;  /* always use 4 length bytes */
171           buf[2] = uid->len >> 16;
172           buf[3] = uid->len >>  8;
173           buf[4] = uid->len;
174         }
175         gcry_md_write( md, buf, 5 );
176     }
177
178     if(uid->attrib_data)
179       gcry_md_write (md, uid->attrib_data, uid->attrib_len );
180     else
181       gcry_md_write (md, uid->name, uid->len );
182 }
183
184
185 /*
186  * Helper to hash some parts from the signature
187  */
188 static void
189 hash_sigversion_to_magic (gcry_md_hd_t md, const PKT_signature *sig)
190 {
191     if (sig->version >= 4)
192         gcry_md_putc (md, sig->version);
193     gcry_md_putc (md, sig->sig_class);
194     if (sig->version < 4) {
195         u32 a = sig->timestamp;
196         gcry_md_putc (md, (a >> 24) & 0xff );
197         gcry_md_putc (md, (a >> 16) & 0xff );
198         gcry_md_putc (md, (a >>  8) & 0xff );
199         gcry_md_putc (md,  a           & 0xff );
200     }
201     else {
202         byte buf[6];
203         size_t n;
204
205         gcry_md_putc (md, sig->pubkey_algo);
206         gcry_md_putc (md, sig->digest_algo);
207         if (sig->hashed) {
208             n = sig->hashed->len;
209             gcry_md_putc (md, (n >> 8) );
210             gcry_md_putc (md,  n       );
211             gcry_md_write (md, sig->hashed->data, n );
212             n += 6;
213         }
214         else {
215             gcry_md_putc (md, 0);  /* always hash the length of the subpacket*/
216             gcry_md_putc (md, 0);
217             n = 6;
218         }
219         /* add some magic */
220         buf[0] = sig->version;
221         buf[1] = 0xff;
222         buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
223         buf[3] = n >> 16;
224         buf[4] = n >>  8;
225         buf[5] = n;
226         gcry_md_write (md, buf, 6);
227     }
228 }
229
230 /* Perform the sign operation.  If CACHE_NONCE is given the agent is
231    advised to use that cached passphrase fro the key.  */
232 static int
233 do_sign (PKT_public_key *pksk, PKT_signature *sig,
234          gcry_md_hd_t md, int mdalgo, const char *cache_nonce)
235 {
236   gpg_error_t err;
237   gcry_mpi_t frame;
238   byte *dp;
239   char *hexgrip;
240
241   if (pksk->timestamp > sig->timestamp )
242     {
243       ulong d = pksk->timestamp - sig->timestamp;
244       log_info (d==1 ? _("key has been created %lu second "
245                          "in future (time warp or clock problem)\n")
246                 : _("key has been created %lu seconds "
247                     "in future (time warp or clock problem)\n"), d );
248       if (!opt.ignore_time_conflict)
249         return gpg_error (GPG_ERR_TIME_CONFLICT);
250     }
251
252
253   print_pubkey_algo_note (pksk->pubkey_algo);
254
255   if (!mdalgo)
256     mdalgo = gcry_md_get_algo (md);
257
258   print_digest_algo_note (mdalgo);
259   dp = gcry_md_read  (md, mdalgo);
260   sig->digest_algo = mdalgo;
261   sig->digest_start[0] = dp[0];
262   sig->digest_start[1] = dp[1];
263   sig->data[0] = NULL;
264   sig->data[1] = NULL;
265
266
267   err = hexkeygrip_from_pk (pksk, &hexgrip);
268   if (!err)
269     {
270       char *desc;
271       gcry_sexp_t s_sigval;
272
273       desc = gpg_format_keydesc (pksk, 0, 1);
274       err = agent_pksign (NULL/*ctrl*/, cache_nonce, hexgrip, desc,
275                           pksk->keyid, pksk->main_keyid, pksk->pubkey_algo,
276                           dp, gcry_md_get_algo_dlen (mdalgo), mdalgo,
277                           &s_sigval);
278       xfree (desc);
279
280       if (err)
281         ;
282       else if (pksk->pubkey_algo == GCRY_PK_RSA
283                || pksk->pubkey_algo == GCRY_PK_RSA_S)
284         sig->data[0] = mpi_from_sexp (s_sigval, "s");
285       else
286         {
287           sig->data[0] = mpi_from_sexp (s_sigval, "r");
288           sig->data[1] = mpi_from_sexp (s_sigval, "s");
289         }
290
291       gcry_sexp_release (s_sigval);
292     }
293   xfree (hexgrip);
294
295   /* Check that the signature verification worked and nothing is
296    * fooling us e.g. by a bug in the signature create code or by
297    * deliberately introduced faults.  */
298   if (!err && !opt.no_sig_create_check)
299     {
300       PKT_public_key *pk = xmalloc_clear (sizeof *pk);
301
302       if (get_pubkey (pk, sig->keyid ))
303         err = gpg_error (GPG_ERR_NO_PUBKEY);
304       else
305         {
306           frame = encode_md_value (pk, md, sig->digest_algo );
307           if (!frame)
308             err = gpg_error (GPG_ERR_GENERAL);
309           else
310             err = pk_verify (pk->pubkey_algo, frame, sig->data, pk->pkey);
311           gcry_mpi_release (frame);
312         }
313       if (err)
314         log_error (_("checking created signature failed: %s\n"),
315                    g10_errstr (err));
316       free_public_key (pk);
317     }
318
319   if (err)
320     log_error (_("signing failed: %s\n"), g10_errstr (err));
321   else
322     {
323       if (opt.verbose)
324         {
325           char *ustr = get_user_id_string_native (sig->keyid);
326           log_info (_("%s/%s signature from: \"%s\"\n"),
327                     openpgp_pk_algo_name (pksk->pubkey_algo),
328                     openpgp_md_algo_name (sig->digest_algo),
329                     ustr);
330           xfree (ustr);
331         }
332     }
333   return err;
334 }
335
336
337 int
338 complete_sig (PKT_signature *sig, PKT_public_key *pksk, gcry_md_hd_t md,
339               const char *cache_nonce)
340 {
341   int rc;
342
343   /* if (!(rc = check_secret_key (pksk, 0))) */
344   rc = do_sign (pksk, sig, md, 0, cache_nonce);
345   return rc;
346 }
347
348
349 /* Return true if the key seems to be on a version 1 OpenPGP card.
350    This works by asking the agent and may fail if the card has not yet
351    been used with the agent.  */
352 static int
353 openpgp_card_v1_p (PKT_public_key *pk)
354 {
355   gpg_error_t err;
356   int result;
357
358   /* Shortcut if we are not using RSA: The v1 cards only support RSA
359      thus there is no point in looking any further.  */
360   if (!is_RSA (pk->pubkey_algo))
361     return 0;
362
363   if (!pk->flags.serialno_valid)
364     {
365       char *hexgrip;
366
367       err = hexkeygrip_from_pk (pk, &hexgrip);
368       if (err)
369         {
370           log_error ("error computing a keygrip: %s\n", gpg_strerror (err));
371           return 0; /* Ooops.  */
372         }
373
374       xfree (pk->serialno);
375       agent_get_keyinfo (NULL, hexgrip, &pk->serialno);
376       xfree (hexgrip);
377       pk->flags.serialno_valid = 1;
378     }
379
380   if (!pk->serialno)
381     result = 0; /* Error from a past agent_get_keyinfo or no card.  */
382   else
383     {
384       /* The version number of the card is included in the serialno.  */
385       result = !strncmp (pk->serialno, "D2760001240101", 14);
386     }
387   return result;
388 }
389
390
391
392 static int
393 match_dsa_hash (unsigned int qbytes)
394 {
395   if (qbytes <= 20)
396     return DIGEST_ALGO_SHA1;
397
398   if (qbytes <= 28)
399     return DIGEST_ALGO_SHA224;
400
401   if (qbytes <= 32)
402     return DIGEST_ALGO_SHA256;
403
404   if (qbytes <= 48)
405     return DIGEST_ALGO_SHA384;
406
407   if (qbytes <= 66 )    /* 66 corresponds to 521 (64 to 512) */
408     return DIGEST_ALGO_SHA512;
409
410   return DEFAULT_DIGEST_ALGO;
411   /* DEFAULT_DIGEST_ALGO will certainly fail, but it's the best wrong
412      answer we have if a digest larger than 512 bits is requested.  */
413 }
414
415
416 /*
417   First try --digest-algo.  If that isn't set, see if the recipient
418   has a preferred algorithm (which is also filtered through
419   --preferred-digest-prefs).  If we're making a signature without a
420   particular recipient (i.e. signing, rather than signing+encrypting)
421   then take the first algorithm in --preferred-digest-prefs that is
422   usable for the pubkey algorithm.  If --preferred-digest-prefs isn't
423   set, then take the OpenPGP default (i.e. SHA-1).
424
425   Possible improvement: Use the highest-ranked usable algorithm from
426   the signing key prefs either before or after using the personal
427   list?
428 */
429 static int
430 hash_for (PKT_public_key *pk)
431 {
432   if (opt.def_digest_algo)
433     {
434       return opt.def_digest_algo;
435     }
436   else if (recipient_digest_algo)
437     {
438       return recipient_digest_algo;
439     }
440   else if (pk->pubkey_algo == PUBKEY_ALGO_DSA
441            || pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
442     {
443       unsigned int qbytes = gcry_mpi_get_nbits (pk->pkey[1]);
444
445       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
446         qbytes = ecdsa_qbits_from_Q (qbytes);
447       qbytes = qbytes/8;
448
449       /* It's a DSA key, so find a hash that is the same size as q or
450          larger.  If q is 160, assume it is an old DSA key and use a
451          160-bit hash unless --enable-dsa2 is set, in which case act
452          like a new DSA key that just happens to have a 160-bit q
453          (i.e. allow truncation).  If q is not 160, by definition it
454          must be a new DSA key. */
455
456       if (opt.personal_digest_prefs)
457         {
458           prefitem_t *prefs;
459
460           if (qbytes != 20 || opt.flags.dsa2)
461             {
462               for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
463                 if (gcry_md_get_algo_dlen (prefs->value) >= qbytes)
464                   return prefs->value;
465             }
466           else
467             {
468               for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
469                 if (gcry_md_get_algo_dlen (prefs->value) == qbytes)
470                   return prefs->value;
471             }
472         }
473
474       return match_dsa_hash(qbytes);
475     }
476   else if (openpgp_card_v1_p (pk))
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_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 recipient 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                     || sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
931                   {
932                     int temp_hashlen = (gcry_mpi_get_nbits
933                                         (sk_rover->pk->pkey[1]));
934
935                     if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
936                       temp_hashlen = ecdsa_qbits_from_Q (temp_hashlen);
937                     temp_hashlen = (temp_hashlen+7)/8;
938
939                     /* Pick a hash that is large enough for our
940                        largest q */
941
942                     if (hint.digest_length<temp_hashlen)
943                       hint.digest_length=temp_hashlen;
944                   }
945                 /* FIXME: need toall gpg-agent */
946                 /* else if (sk_rover->pk->is_protected */
947                 /*          && sk_rover->pk->protect.s2k.mode == 1002) */
948                 /*   smartcard = 1;  */
949               }
950
951             /* Current smartcards only do 160-bit hashes.  If we have
952                to have a >160-bit hash, then we can't use the
953                recipient prefs as we'd need both =160 and >160 at the
954                same time and recipient prefs currently require a
955                single hash for all signatures.  All this may well have
956                to change as the cards add algorithms. */
957
958             if (!smartcard || (smartcard && hint.digest_length==20))
959               if ( (algo=
960                    select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint)) > 0)
961                 recipient_digest_algo=algo;
962           }
963       }
964
965     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
966       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
967
968     if( !multifile )
969         iobuf_push_filter( inp, md_filter, &mfx );
970
971     if( detached && !encryptflag && !RFC1991 )
972         afx->what = 2;
973
974     if( opt.armor && !outfile  )
975         push_armor_filter (afx, out);
976
977     if( encryptflag ) {
978         efx.pk_list = pk_list;
979         /* fixme: set efx.cfx.datalen if known */
980         iobuf_push_filter( out, encrypt_filter, &efx );
981     }
982
983     if( opt.compress_algo && !outfile && ( !detached || opt.compress_sigs) )
984       {
985         int compr_algo=opt.compress_algo;
986
987         /* If not forced by user */
988         if(compr_algo==-1)
989           {
990             /* If we're not encrypting, then select_algo_from_prefs
991                will fail and we'll end up with the default.  If we are
992                encrypting, select_algo_from_prefs cannot fail since
993                there is an assumed preference for uncompressed data.
994                Still, if it did fail, we'll also end up with the
995                default. */
996
997             if((compr_algo=
998                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
999               compr_algo=default_compress_algo();
1000           }
1001         else if(!opt.expert && pk_list
1002                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
1003                                           compr_algo,NULL)!=compr_algo)
1004           log_info(_("WARNING: forcing compression algorithm %s (%d)"
1005                      " violates recipient preferences\n"),
1006                    compress_algo_to_string(compr_algo),compr_algo);
1007
1008         /* algo 0 means no compression */
1009         if( compr_algo )
1010           push_compress_filter(out,&zfx,compr_algo);
1011       }
1012
1013     /* Write the one-pass signature packets if needed */
1014     if (!detached && !RFC1991) {
1015         rc = write_onepass_sig_packets (sk_list, out,
1016                                         opt.textmode && !outfile ? 0x01:0x00);
1017         if (rc)
1018             goto leave;
1019     }
1020
1021     write_status_begin_signing (mfx.md);
1022
1023     /* Setup the inner packet. */
1024     if( detached ) {
1025         if( multifile ) {
1026             strlist_t sl;
1027
1028             if( opt.verbose )
1029                 log_info(_("signing:") );
1030             /* must walk reverse trough this list */
1031             for( sl = strlist_last(filenames); sl;
1032                         sl = strlist_prev( filenames, sl ) ) {
1033                 inp = iobuf_open(sl->d);
1034                 if (inp && is_secured_file (iobuf_get_fd (inp)))
1035                   {
1036                     iobuf_close (inp);
1037                     inp = NULL;
1038                     gpg_err_set_errno (EPERM);
1039                   }
1040                 if( !inp )
1041                   {
1042                     rc = gpg_error_from_syserror ();
1043                     log_error(_("can't open '%s': %s\n"),
1044                               sl->d,strerror(errno));
1045                     goto leave;
1046                   }
1047                 handle_progress (pfx, inp, sl->d);
1048                 if( opt.verbose )
1049                     fprintf(stderr, " '%s'", sl->d );
1050                 if(opt.textmode)
1051                   {
1052                     memset( &tfx, 0, sizeof tfx);
1053                     iobuf_push_filter( inp, text_filter, &tfx );
1054                   }
1055                 iobuf_push_filter( inp, md_filter, &mfx );
1056                 while( iobuf_get(inp) != -1 )
1057                     ;
1058                 iobuf_close(inp); inp = NULL;
1059             }
1060             if( opt.verbose )
1061                 putc( '\n', stderr );
1062         }
1063         else {
1064             /* read, so that the filter can calculate the digest */
1065             while( iobuf_get(inp) != -1 )
1066                 ;
1067         }
1068     }
1069     else {
1070         rc = write_plaintext_packet (out, inp, fname,
1071                                      opt.textmode && !outfile ? 't':'b');
1072     }
1073
1074     /* catch errors from above */
1075     if (rc)
1076         goto leave;
1077
1078     /* write the signatures */
1079     rc = write_signature_packets (sk_list, out, mfx.md,
1080                                   opt.textmode && !outfile? 0x01 : 0x00,
1081                                   0, duration, detached ? 'D':'S', NULL);
1082     if( rc )
1083         goto leave;
1084
1085
1086   leave:
1087     if( rc )
1088         iobuf_cancel(out);
1089     else {
1090         iobuf_close(out);
1091         if (encryptflag)
1092             write_status( STATUS_END_ENCRYPTION );
1093     }
1094     iobuf_close(inp);
1095     gcry_md_close ( mfx.md );
1096     release_sk_list( sk_list );
1097     release_pk_list( pk_list );
1098     recipient_digest_algo=0;
1099     release_progress_context (pfx);
1100     release_armor_context (afx);
1101     return rc;
1102 }
1103
1104
1105
1106 /****************
1107  * make a clear signature. note that opt.armor is not needed
1108  */
1109 int
1110 clearsign_file( const char *fname, strlist_t locusr, const char *outfile )
1111 {
1112     armor_filter_context_t *afx;
1113     progress_filter_context_t *pfx;
1114     gcry_md_hd_t textmd = NULL;
1115     IOBUF inp = NULL, out = NULL;
1116     PACKET pkt;
1117     int rc = 0;
1118     SK_LIST sk_list = NULL;
1119     SK_LIST sk_rover = NULL;
1120     int old_style = RFC1991;
1121     int only_md5 = 0;
1122     u32 duration=0;
1123
1124     pfx = new_progress_context ();
1125     afx = new_armor_context ();
1126     init_packet( &pkt );
1127
1128     if(!opt.force_v3_sigs && !RFC1991)
1129       {
1130         if(opt.ask_sig_expire && !opt.batch)
1131           duration=ask_expire_interval(1,opt.def_sig_expire);
1132         else
1133           duration=parse_expire_string(opt.def_sig_expire);
1134       }
1135
1136     /* Note: In the old non-agent version the following call used to
1137        unprotect the secret key.  This is now done on demand by the agent.  */
1138     if( (rc=build_sk_list( locusr, &sk_list, PUBKEY_USAGE_SIG )) )
1139         goto leave;
1140
1141     if( !old_style && !duration )
1142         old_style = only_old_style( sk_list );
1143
1144     if(PGP2 && !only_old_style(sk_list))
1145       {
1146         log_info(_("you can only clearsign with PGP 2.x style keys "
1147                    "while in --pgp2 mode\n"));
1148         compliance_failure();
1149       }
1150
1151     /* prepare iobufs */
1152     inp = iobuf_open(fname);
1153     if (inp && is_secured_file (iobuf_get_fd (inp)))
1154       {
1155         iobuf_close (inp);
1156         inp = NULL;
1157         gpg_err_set_errno (EPERM);
1158       }
1159     if( !inp ) {
1160         rc = gpg_error_from_syserror ();
1161         log_error (_("can't open '%s': %s\n"),
1162                    fname? fname: "[stdin]", strerror(errno) );
1163         goto leave;
1164     }
1165     handle_progress (pfx, inp, fname);
1166
1167     if( outfile ) {
1168         if (is_secured_filename (outfile) ) {
1169             outfile = NULL;
1170             gpg_err_set_errno (EPERM);
1171         }
1172         else
1173             out = iobuf_create( outfile );
1174         if( !out )
1175           {
1176             rc = gpg_error_from_syserror ();
1177             log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
1178             goto leave;
1179           }
1180         else if( opt.verbose )
1181             log_info(_("writing to '%s'\n"), outfile );
1182     }
1183     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname, 1, &out )) )
1184         goto leave;
1185
1186     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1187
1188     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1189       {
1190         if (hash_for (sk_rover->pk) == DIGEST_ALGO_MD5)
1191           only_md5 = 1;
1192         else
1193           {
1194             only_md5 = 0;
1195             break;
1196           }
1197       }
1198
1199     if( !(old_style && only_md5) ) {
1200         const char *s;
1201         int any = 0;
1202         byte hashs_seen[256];
1203
1204         memset( hashs_seen, 0, sizeof hashs_seen );
1205         iobuf_writestr(out, "Hash: " );
1206         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1207             int i = hash_for (sk_rover->pk);
1208
1209             if( !hashs_seen[ i & 0xff ] ) {
1210                 s = gcry_md_algo_name ( i );
1211                 if( s ) {
1212                     hashs_seen[ i & 0xff ] = 1;
1213                     if( any )
1214                         iobuf_put(out, ',' );
1215                     iobuf_writestr(out, s );
1216                     any = 1;
1217                 }
1218             }
1219         }
1220         assert(any);
1221         iobuf_writestr(out, LF );
1222     }
1223
1224     if( opt.not_dash_escaped )
1225       iobuf_writestr( out,
1226                   "NotDashEscaped: You need GnuPG to verify this message" LF );
1227     iobuf_writestr(out, LF );
1228
1229     if ( gcry_md_open (&textmd, 0, 0) )
1230       BUG ();
1231     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1232       gcry_md_enable (textmd, hash_for(sk_rover->pk));
1233
1234     if ( DBG_HASHING )
1235       gcry_md_debug ( textmd, "clearsign" );
1236
1237     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
1238                         opt.escape_from, (old_style && only_md5) );
1239     /* fixme: check for read errors */
1240
1241     /* now write the armor */
1242     afx->what = 2;
1243     push_armor_filter (afx, out);
1244
1245     /* Write the signatures.  */
1246     rc = write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C',
1247                                   NULL);
1248     if( rc )
1249         goto leave;
1250
1251   leave:
1252     if( rc )
1253         iobuf_cancel(out);
1254     else
1255         iobuf_close(out);
1256     iobuf_close(inp);
1257     gcry_md_close ( textmd );
1258     release_sk_list( sk_list );
1259     release_progress_context (pfx);
1260     release_armor_context (afx);
1261     return rc;
1262 }
1263
1264 /*
1265  * Sign and conventionally encrypt the given file.
1266  * FIXME: Far too much code is duplicated - revamp the whole file.
1267  */
1268 int
1269 sign_symencrypt_file (const char *fname, strlist_t locusr)
1270 {
1271     armor_filter_context_t *afx;
1272     progress_filter_context_t *pfx;
1273     compress_filter_context_t zfx;
1274     md_filter_context_t mfx;
1275     text_filter_context_t tfx;
1276     cipher_filter_context_t cfx;
1277     IOBUF inp = NULL, out = NULL;
1278     PACKET pkt;
1279     STRING2KEY *s2k = NULL;
1280     int rc = 0;
1281     SK_LIST sk_list = NULL;
1282     SK_LIST sk_rover = NULL;
1283     int algo;
1284     u32 duration=0;
1285     int canceled;
1286
1287     pfx = new_progress_context ();
1288     afx = new_armor_context ();
1289     memset( &zfx, 0, sizeof zfx);
1290     memset( &mfx, 0, sizeof mfx);
1291     memset( &tfx, 0, sizeof tfx);
1292     memset( &cfx, 0, sizeof cfx);
1293     init_packet( &pkt );
1294
1295     if(!opt.force_v3_sigs && !RFC1991)
1296       {
1297         if(opt.ask_sig_expire && !opt.batch)
1298           duration=ask_expire_interval(1,opt.def_sig_expire);
1299         else
1300           duration=parse_expire_string(opt.def_sig_expire);
1301       }
1302
1303     /* Note: In the old non-agent version the following call used to
1304        unprotect the secret key.  This is now done on demand by the agent.  */
1305     rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_SIG);
1306     if (rc)
1307         goto leave;
1308
1309     /* prepare iobufs */
1310     inp = iobuf_open(fname);
1311     if (inp && is_secured_file (iobuf_get_fd (inp)))
1312       {
1313         iobuf_close (inp);
1314         inp = NULL;
1315         gpg_err_set_errno (EPERM);
1316       }
1317     if( !inp ) {
1318         rc = gpg_error_from_syserror ();
1319         log_error (_("can't open '%s': %s\n"),
1320                    fname? fname: "[stdin]", strerror(errno) );
1321         goto leave;
1322     }
1323     handle_progress (pfx, inp, fname);
1324
1325     /* prepare key */
1326     s2k = xmalloc_clear( sizeof *s2k );
1327     s2k->mode = RFC1991? 0:opt.s2k_mode;
1328     s2k->hash_algo = S2K_DIGEST_ALGO;
1329
1330     algo = default_cipher_algo();
1331     if (!opt.quiet || !opt.batch)
1332         log_info (_("%s encryption will be used\n"),
1333                   openpgp_cipher_algo_name (algo) );
1334     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, &canceled);
1335
1336     if (!cfx.dek || !cfx.dek->keylen) {
1337         rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
1338         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1339         goto leave;
1340     }
1341
1342     /* We have no way to tell if the recipient can handle messages
1343        with an MDC, so this defaults to no.  Perhaps in a few years,
1344        this can be defaulted to yes.  Note that like regular
1345        encrypting, --force-mdc overrides --disable-mdc. */
1346     if(opt.force_mdc)
1347       cfx.dek->use_mdc=1;
1348
1349     /* now create the outfile */
1350     rc = open_outfile (GNUPG_INVALID_FD, fname, opt.armor? 1:0, &out);
1351     if (rc)
1352         goto leave;
1353
1354     /* prepare to calculate the MD over the input */
1355     if (opt.textmode)
1356         iobuf_push_filter (inp, text_filter, &tfx);
1357     if ( gcry_md_open (&mfx.md, 0, 0) )
1358       BUG ();
1359     if ( DBG_HASHING )
1360       gcry_md_debug (mfx.md, "symc-sign");
1361
1362     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1363       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
1364
1365     iobuf_push_filter (inp, md_filter, &mfx);
1366
1367     /* Push armor output filter */
1368     if (opt.armor)
1369         push_armor_filter (afx, out);
1370
1371     /* Write the symmetric key packet */
1372     /*(current filters: armor)*/
1373     if (!RFC1991) {
1374         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1375         enc->version = 4;
1376         enc->cipher_algo = cfx.dek->algo;
1377         enc->s2k = *s2k;
1378         pkt.pkttype = PKT_SYMKEY_ENC;
1379         pkt.pkt.symkey_enc = enc;
1380         if( (rc = build_packet( out, &pkt )) )
1381             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1382         xfree(enc);
1383     }
1384
1385     /* Push the encryption filter */
1386     iobuf_push_filter( out, cipher_filter, &cfx );
1387
1388     /* Push the compress filter */
1389     if (default_compress_algo())
1390       push_compress_filter(out,&zfx,default_compress_algo());
1391
1392     /* Write the one-pass signature packets */
1393     /*(current filters: zip - encrypt - armor)*/
1394     if (!RFC1991) {
1395         rc = write_onepass_sig_packets (sk_list, out,
1396                                         opt.textmode? 0x01:0x00);
1397         if (rc)
1398             goto leave;
1399     }
1400
1401     write_status_begin_signing (mfx.md);
1402
1403     /* Pipe data through all filters; i.e. write the signed stuff */
1404     /*(current filters: zip - encrypt - armor)*/
1405     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1406     if (rc)
1407         goto leave;
1408
1409     /* Write the signatures */
1410     /*(current filters: zip - encrypt - armor)*/
1411     rc = write_signature_packets (sk_list, out, mfx.md,
1412                                   opt.textmode? 0x01 : 0x00,
1413                                   0, duration, 'S', NULL);
1414     if( rc )
1415         goto leave;
1416
1417
1418   leave:
1419     if( rc )
1420         iobuf_cancel(out);
1421     else {
1422         iobuf_close(out);
1423         write_status( STATUS_END_ENCRYPTION );
1424     }
1425     iobuf_close(inp);
1426     release_sk_list( sk_list );
1427     gcry_md_close( mfx.md );
1428     xfree(cfx.dek);
1429     xfree(s2k);
1430     release_progress_context (pfx);
1431     release_armor_context (afx);
1432     return rc;
1433 }
1434
1435
1436 /****************
1437  * Create a signature packet for the given public key certificate and
1438  * the user id and return it in ret_sig. User signature class SIGCLASS
1439  * user-id is not used (and may be NULL if sigclass is 0x20) If
1440  * DIGEST_ALGO is 0 the function selects an appropriate one.
1441  * SIGVERSION gives the minimal required signature packet version;
1442  * this is needed so that special properties like local sign are not
1443  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1444  * the timestamp to use for the signature. 0 means "now" */
1445 int
1446 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1447                     PKT_user_id *uid, PKT_public_key *subpk,
1448                     PKT_public_key *pksk,
1449                     int sigclass, int digest_algo,
1450                     int sigversion, u32 timestamp, u32 duration,
1451                     int (*mksubpkt)(PKT_signature *, void *), void *opaque,
1452                     const char *cache_nonce)
1453 {
1454     PKT_signature *sig;
1455     int rc=0;
1456     gcry_md_hd_t md;
1457
1458     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1459             || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1460             || sigclass == 0x30 || sigclass == 0x28 );
1461
1462     if (opt.force_v4_certs)
1463         sigversion = 4;
1464
1465     if (sigversion < pksk->version)
1466         sigversion = pksk->version;
1467
1468     /* If you are making a signature on a v4 key using your v3 key, it
1469        doesn't make sense to generate a v3 sig.  After all, no v3-only
1470        PGP implementation could understand the v4 key in the first
1471        place.  Note that this implies that a signature on an attribute
1472        uid is usually going to be v4 as well, since they are not
1473        generally found on v3 keys. */
1474     if (sigversion < pk->version)
1475         sigversion = pk->version;
1476
1477     if( !digest_algo )
1478       {
1479         /* Basically, this means use SHA1 always unless it's a v3 RSA
1480            key making a v3 cert (use MD5), or the user specified
1481            something (use whatever they said), or it's DSA (use the
1482            best match).  They still can't pick an inappropriate hash
1483            for DSA or the signature will fail.  Note that this still
1484            allows the caller of make_keysig_packet to override the
1485            user setting if it must. */
1486
1487         if(opt.cert_digest_algo)
1488           digest_algo=opt.cert_digest_algo;
1489         else if(pksk->pubkey_algo == PUBKEY_ALGO_RSA
1490                 && pk->version<4 && sigversion<4)
1491           digest_algo = DIGEST_ALGO_MD5;
1492         else if(pksk->pubkey_algo == PUBKEY_ALGO_DSA)
1493           digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
1494         else if(pksk->pubkey_algo == PUBKEY_ALGO_ECDSA )
1495           digest_algo = match_dsa_hash (ecdsa_qbits_from_Q
1496                                         (gcry_mpi_get_nbits (pksk->pkey[1]))/8);
1497         else
1498           digest_algo = DIGEST_ALGO_SHA1;
1499       }
1500
1501     if ( gcry_md_open (&md, digest_algo, 0 ) )
1502       BUG ();
1503
1504     /* Hash the public key certificate. */
1505     hash_public_key( md, pk );
1506
1507     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1508       {
1509         /* hash the subkey binding/backsig/revocation */
1510         hash_public_key( md, subpk );
1511       }
1512     else if( sigclass != 0x1F && sigclass != 0x20 )
1513       {
1514         /* hash the user id */
1515         hash_uid (md, sigversion, uid);
1516       }
1517     /* and make the signature packet */
1518     sig = xmalloc_clear( sizeof *sig );
1519     sig->version = sigversion;
1520     sig->flags.exportable=1;
1521     sig->flags.revocable=1;
1522     keyid_from_pk (pksk, sig->keyid);
1523     sig->pubkey_algo = pksk->pubkey_algo;
1524     sig->digest_algo = digest_algo;
1525     if(timestamp)
1526       sig->timestamp=timestamp;
1527     else
1528       sig->timestamp=make_timestamp();
1529     if(duration)
1530       sig->expiredate=sig->timestamp+duration;
1531     sig->sig_class = sigclass;
1532     if( sig->version >= 4 )
1533       {
1534         build_sig_subpkt_from_sig( sig );
1535         mk_notation_policy_etc (sig, pk, pksk);
1536       }
1537
1538     /* Crucial that the call to mksubpkt comes LAST before the calls
1539        to finalize the sig as that makes it possible for the mksubpkt
1540        function to get a reliable pointer to the subpacket area. */
1541     if( sig->version >= 4 && mksubpkt )
1542         rc = (*mksubpkt)( sig, opaque );
1543
1544     if( !rc ) {
1545         hash_sigversion_to_magic (md, sig);
1546         gcry_md_final (md);
1547
1548         rc = complete_sig (sig, pksk, md, cache_nonce);
1549     }
1550
1551     gcry_md_close (md);
1552     if( rc )
1553         free_seckey_enc( sig );
1554     else
1555         *ret_sig = sig;
1556     return rc;
1557 }
1558
1559
1560
1561 /****************
1562  * Create a new signature packet based on an existing one.
1563  * Only user ID signatures are supported for now.
1564  * PK is the public key to work on.
1565  * PKSK is the key used to make the signature.
1566  *
1567  * TODO: Merge this with make_keysig_packet.
1568  */
1569 int
1570 update_keysig_packet( PKT_signature **ret_sig,
1571                       PKT_signature *orig_sig,
1572                       PKT_public_key *pk,
1573                       PKT_user_id *uid,
1574                       PKT_public_key *subpk,
1575                       PKT_public_key *pksk,
1576                       int (*mksubpkt)(PKT_signature *, void *),
1577                       void *opaque)
1578 {
1579     PKT_signature *sig;
1580     int rc = 0;
1581     int digest_algo;
1582     gcry_md_hd_t md;
1583
1584     if ((!orig_sig || !pk || !pksk)
1585         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1586         || (orig_sig->sig_class == 0x18 && !subpk))
1587       return G10ERR_GENERAL;
1588
1589     if ( opt.cert_digest_algo )
1590       digest_algo = opt.cert_digest_algo;
1591     else
1592       digest_algo = orig_sig->digest_algo;
1593
1594     if ( gcry_md_open (&md, digest_algo, 0 ) )
1595       BUG ();
1596
1597     /* Hash the public key certificate and the user id. */
1598     hash_public_key( md, pk );
1599
1600     if( orig_sig->sig_class == 0x18 )
1601       hash_public_key( md, subpk );
1602     else
1603       hash_uid (md, orig_sig->version, uid);
1604
1605     /* create a new signature packet */
1606     sig = copy_signature (NULL, orig_sig);
1607
1608     sig->digest_algo=digest_algo;
1609
1610     /* We need to create a new timestamp so that new sig expiration
1611        calculations are done correctly... */
1612     sig->timestamp=make_timestamp();
1613
1614     /* ... but we won't make a timestamp earlier than the existing
1615        one. */
1616     while(sig->timestamp<=orig_sig->timestamp)
1617       {
1618         gnupg_sleep (1);
1619         sig->timestamp=make_timestamp();
1620       }
1621
1622     /* Note that already expired sigs will remain expired (with a
1623        duration of 1) since build-packet.c:build_sig_subpkt_from_sig
1624        detects this case. */
1625
1626     if( sig->version >= 4 )
1627       {
1628         /* Put the updated timestamp into the sig.  Note that this
1629            will automagically lower any sig expiration dates to
1630            correctly correspond to the differences in the timestamps
1631            (i.e. the duration will shrink). */
1632         build_sig_subpkt_from_sig( sig );
1633
1634         if (mksubpkt)
1635           rc = (*mksubpkt)(sig, opaque);
1636       }
1637
1638     if (!rc) {
1639         hash_sigversion_to_magic (md, sig);
1640         gcry_md_final (md);
1641
1642         rc = complete_sig (sig, pksk, md, NULL);
1643     }
1644
1645     gcry_md_close (md);
1646     if( rc )
1647         free_seckey_enc (sig);
1648     else
1649         *ret_sig = sig;
1650     return rc;
1651 }