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