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