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