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