* keydb.h, pkclist.c (select_algo_from_prefs, algo_available): Pass a
[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             union pref_hint hint;
870             int algo,smartcard=0;
871
872             hint.digest_length=0;
873
874             /* Of course, if the recipient asks for something
875                unreasonable (like the wrong hash for a DSA key) then
876                don't do it.  Check all sk's - if any are DSA or live
877                on a smartcard, then the hash has restrictions and we
878                may not be able to give the recipient what they want.
879                For DSA, pass a hint for the largest q we have.  Note
880                that this means that a q>160 key will override a q=160
881                key and force the use of truncation for the q=160 key.
882                The alternative would be to ignore the recipient prefs
883                completely and get a different hash for each DSA key in
884                hash_for().  The override behavior here is more or less
885                reasonable as it is under the control of the user which
886                keys they sign with for a given message and the fact
887                that the message with multiple signatures won't be
888                usable on an implementation that doesn't understand
889                DSA2 anyway. */
890
891             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
892               {
893                 if(sk_rover->sk->pubkey_algo==PUBKEY_ALGO_DSA)
894                   {
895                     int temp_hashlen=mpi_get_nbits(sk_rover->sk->skey[1])/8;
896
897                     /* Pick a hash that is large enough for our
898                        largest q */
899
900                     if(hint.digest_length<temp_hashlen)
901                       hint.digest_length=temp_hashlen;
902                   }
903                 else if(sk_rover->sk->is_protected
904                         && sk_rover->sk->protect.s2k.mode==1002)
905                   smartcard=1;
906               }
907
908             /* Current smartcards only do 160-bit hashes.  If we have
909                to have a >160-bit hash, then we can't use the
910                recipient prefs as we'd need both =160 and >160 at the
911                same time and recipient prefs currently require a
912                single hash for all signatures.  All this may well have
913                to change as the cards add algorithms. */
914
915             if(!smartcard || (smartcard && hint.digest_length==20))
916               if((algo=
917                   select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint))>0)
918                 recipient_digest_algo=algo;
919           }
920       }
921
922     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
923         PKT_secret_key *sk = sk_rover->sk;
924         md_enable(mfx.md, hash_for(sk));
925     }
926
927     if( !multifile )
928         iobuf_push_filter( inp, md_filter, &mfx );
929
930     if( detached && !encryptflag && !RFC1991 )
931         afx.what = 2;
932
933     if( opt.armor && !outfile  )
934         iobuf_push_filter( out, armor_filter, &afx );
935
936     if( encryptflag ) {
937         efx.pk_list = pk_list;
938         /* fixme: set efx.cfx.datalen if known */
939         iobuf_push_filter( out, encrypt_filter, &efx );
940     }
941
942     if( opt.compress_algo && !outfile && ( !detached || opt.compress_sigs) )
943       {
944         int compr_algo=opt.compress_algo;
945
946         /* If not forced by user */
947         if(compr_algo==-1)
948           {
949             /* If we're not encrypting, then select_algo_from_prefs
950                will fail and we'll end up with the default.  If we are
951                encrypting, select_algo_from_prefs cannot fail since
952                there is an assumed preference for uncompressed data.
953                Still, if it did fail, we'll also end up with the
954                default. */
955  
956             if((compr_algo=
957                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
958               compr_algo=default_compress_algo();
959           }
960         else if(!opt.expert && pk_list
961                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
962                                           compr_algo,NULL)!=compr_algo)
963           log_info(_("WARNING: forcing compression algorithm %s (%d)"
964                      " violates recipient preferences\n"),
965                    compress_algo_to_string(compr_algo),compr_algo);
966
967         /* algo 0 means no compression */
968         if( compr_algo )
969           push_compress_filter(out,&zfx,compr_algo);
970       }
971
972     /* Write the one-pass signature packets if needed */
973     if (!detached && !RFC1991) {
974         rc = write_onepass_sig_packets (sk_list, out,
975                                         opt.textmode && !outfile ? 0x01:0x00);
976         if (rc)
977             goto leave;
978     }
979
980     write_status (STATUS_BEGIN_SIGNING);
981
982     /* Setup the inner packet. */
983     if( detached ) {
984         if( multifile ) {
985             STRLIST sl;
986
987             if( opt.verbose )
988                 log_info(_("signing:") );
989             /* must walk reverse trough this list */
990             for( sl = strlist_last(filenames); sl;
991                         sl = strlist_prev( filenames, sl ) ) {
992                 inp = iobuf_open(sl->d);
993                 if (inp && is_secured_file (iobuf_get_fd (inp)))
994                   {
995                     iobuf_close (inp);
996                     inp = NULL;
997                     errno = EPERM;
998                   }
999                 if( !inp )
1000                   {
1001                     log_error(_("can't open `%s': %s\n"),
1002                               sl->d,strerror(errno));
1003                     rc = G10ERR_OPEN_FILE;
1004                     goto leave;
1005                   }
1006                 handle_progress (&pfx, inp, sl->d);
1007                 if( opt.verbose )
1008                     fprintf(stderr, " `%s'", sl->d );
1009                 if(opt.textmode)
1010                   {
1011                     memset( &tfx, 0, sizeof tfx);
1012                     iobuf_push_filter( inp, text_filter, &tfx );
1013                   }
1014                 iobuf_push_filter( inp, md_filter, &mfx );
1015                 while( iobuf_get(inp) != -1 )
1016                     ;
1017                 iobuf_close(inp); inp = NULL;
1018             }
1019             if( opt.verbose )
1020                 putc( '\n', stderr );
1021         }
1022         else {
1023             /* read, so that the filter can calculate the digest */
1024             while( iobuf_get(inp) != -1 )
1025                 ;
1026         }
1027     }
1028     else {
1029         rc = write_plaintext_packet (out, inp, fname,
1030                                      opt.textmode && !outfile ? 't':'b');
1031     }
1032
1033     /* catch errors from above */
1034     if (rc)
1035         goto leave;
1036
1037     /* write the signatures */
1038     rc = write_signature_packets (sk_list, out, mfx.md,
1039                                   opt.textmode && !outfile? 0x01 : 0x00,
1040                                   0, duration, detached ? 'D':'S');
1041     if( rc )
1042         goto leave;
1043
1044
1045   leave:
1046     if( rc )
1047         iobuf_cancel(out);
1048     else {
1049         iobuf_close(out);
1050         if (encryptflag)
1051             write_status( STATUS_END_ENCRYPTION );
1052     }
1053     iobuf_close(inp);
1054     md_close( mfx.md );
1055     release_sk_list( sk_list );
1056     release_pk_list( pk_list );
1057     recipient_digest_algo=0;
1058     return rc;
1059 }
1060
1061
1062
1063 /****************
1064  * make a clear signature. note that opt.armor is not needed
1065  */
1066 int
1067 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
1068 {
1069     armor_filter_context_t afx;
1070     progress_filter_context_t pfx;
1071     MD_HANDLE textmd = NULL;
1072     IOBUF inp = NULL, out = NULL;
1073     PACKET pkt;
1074     int rc = 0;
1075     SK_LIST sk_list = NULL;
1076     SK_LIST sk_rover = NULL;
1077     int old_style = RFC1991;
1078     int only_md5 = 0;
1079     u32 duration=0;
1080
1081     memset( &afx, 0, sizeof afx);
1082     init_packet( &pkt );
1083
1084     if(!opt.force_v3_sigs && !RFC1991)
1085       {
1086         if(opt.ask_sig_expire && !opt.batch)
1087           duration=ask_expire_interval(1,opt.def_sig_expire);
1088         else
1089           duration=parse_expire_string(opt.def_sig_expire);
1090       }
1091
1092     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
1093         goto leave;
1094
1095     if( !old_style && !duration )
1096         old_style = only_old_style( sk_list );
1097
1098     if(PGP2 && !only_old_style(sk_list))
1099       {
1100         log_info(_("you can only clearsign with PGP 2.x style keys "
1101                    "while in --pgp2 mode\n"));
1102         compliance_failure();
1103       }
1104
1105     /* prepare iobufs */
1106     inp = iobuf_open(fname);
1107     if (inp && is_secured_file (iobuf_get_fd (inp)))
1108       {
1109         iobuf_close (inp);
1110         inp = NULL;
1111         errno = EPERM;
1112       }
1113     if( !inp ) {
1114         log_error(_("can't open `%s': %s\n"), fname? fname: "[stdin]",
1115                                         strerror(errno) );
1116         rc = G10ERR_OPEN_FILE;
1117         goto leave;
1118     }
1119     handle_progress (&pfx, inp, fname);
1120
1121     if( outfile ) {
1122         if (is_secured_filename (outfile) ) {
1123             outfile = NULL;
1124             errno = EPERM;
1125         }
1126         else 
1127             out = iobuf_create( outfile );
1128         if( !out )
1129           {
1130             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
1131             rc = G10ERR_CREATE_FILE;
1132             goto leave;
1133           }
1134         else if( opt.verbose )
1135             log_info(_("writing to `%s'\n"), outfile );
1136     }
1137     else if( (rc = open_outfile( fname, 1, &out )) )
1138         goto leave;
1139
1140     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1141
1142     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1143         PKT_secret_key *sk = sk_rover->sk;
1144         if( hash_for(sk) == DIGEST_ALGO_MD5 )
1145             only_md5 = 1;
1146         else {
1147             only_md5 = 0;
1148             break;
1149         }
1150     }
1151
1152     if( !(old_style && only_md5) ) {
1153         const char *s;
1154         int any = 0;
1155         byte hashs_seen[256];
1156
1157         memset( hashs_seen, 0, sizeof hashs_seen );
1158         iobuf_writestr(out, "Hash: " );
1159         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1160             PKT_secret_key *sk = sk_rover->sk;
1161             int i = hash_for(sk);
1162
1163             if( !hashs_seen[ i & 0xff ] ) {
1164                 s = digest_algo_to_string( i );
1165                 if( s ) {
1166                     hashs_seen[ i & 0xff ] = 1;
1167                     if( any )
1168                         iobuf_put(out, ',' );
1169                     iobuf_writestr(out, s );
1170                     any = 1;
1171                 }
1172             }
1173         }
1174         assert(any);
1175         iobuf_writestr(out, LF );
1176     }
1177
1178     if( opt.not_dash_escaped )
1179       iobuf_writestr( out,
1180                   "NotDashEscaped: You need GnuPG to verify this message" LF );
1181     iobuf_writestr(out, LF );
1182
1183     textmd = md_open(0, 0);
1184     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1185         PKT_secret_key *sk = sk_rover->sk;
1186         md_enable(textmd, hash_for(sk));
1187     }
1188     if ( DBG_HASHING )
1189         md_start_debug( textmd, "clearsign" );
1190     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
1191                         opt.escape_from, (old_style && only_md5) );
1192     /* fixme: check for read errors */
1193
1194     /* now write the armor */
1195     afx.what = 2;
1196     iobuf_push_filter( out, armor_filter, &afx );
1197
1198     /* write the signatures */
1199     rc=write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C');
1200     if( rc )
1201         goto leave;
1202
1203   leave:
1204     if( rc )
1205         iobuf_cancel(out);
1206     else
1207         iobuf_close(out);
1208     iobuf_close(inp);
1209     md_close( textmd );
1210     release_sk_list( sk_list );
1211     return rc;
1212 }
1213
1214 /*
1215  * Sign and conventionally encrypt the given file.
1216  * FIXME: Far too much code is duplicated - revamp the whole file.
1217  */
1218 int
1219 sign_symencrypt_file (const char *fname, STRLIST locusr)
1220 {
1221     armor_filter_context_t afx;
1222     progress_filter_context_t pfx;
1223     compress_filter_context_t zfx;
1224     md_filter_context_t mfx;
1225     text_filter_context_t tfx;
1226     cipher_filter_context_t cfx;
1227     IOBUF inp = NULL, out = NULL;
1228     PACKET pkt;
1229     STRING2KEY *s2k = NULL;
1230     int rc = 0;
1231     SK_LIST sk_list = NULL;
1232     SK_LIST sk_rover = NULL;
1233     int algo;
1234     u32 duration=0;
1235
1236     memset( &afx, 0, sizeof afx);
1237     memset( &zfx, 0, sizeof zfx);
1238     memset( &mfx, 0, sizeof mfx);
1239     memset( &tfx, 0, sizeof tfx);
1240     memset( &cfx, 0, sizeof cfx);
1241     init_packet( &pkt );
1242
1243     if(!opt.force_v3_sigs && !RFC1991)
1244       {
1245         if(opt.ask_sig_expire && !opt.batch)
1246           duration=ask_expire_interval(1,opt.def_sig_expire);
1247         else
1248           duration=parse_expire_string(opt.def_sig_expire);
1249       }
1250
1251     rc = build_sk_list (locusr, &sk_list, 1, PUBKEY_USAGE_SIG);
1252     if (rc) 
1253         goto leave;
1254
1255     /* prepare iobufs */
1256     inp = iobuf_open(fname);
1257     if (inp && is_secured_file (iobuf_get_fd (inp)))
1258       {
1259         iobuf_close (inp);
1260         inp = NULL;
1261         errno = EPERM;
1262       }
1263     if( !inp ) {
1264         log_error(_("can't open `%s': %s\n"), 
1265                   fname? fname: "[stdin]", strerror(errno) );
1266         rc = G10ERR_OPEN_FILE;
1267         goto leave;
1268     }
1269     handle_progress (&pfx, inp, fname);
1270
1271     /* prepare key */
1272     s2k = xmalloc_clear( sizeof *s2k );
1273     s2k->mode = RFC1991? 0:opt.s2k_mode;
1274     s2k->hash_algo = S2K_DIGEST_ALGO;
1275
1276     algo = default_cipher_algo();
1277     if (!opt.quiet || !opt.batch)
1278         log_info (_("%s encryption will be used\n"),
1279                     cipher_algo_to_string(algo) );
1280     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, NULL);
1281
1282     if (!cfx.dek || !cfx.dek->keylen) {
1283         rc = G10ERR_PASSPHRASE;
1284         log_error(_("error creating passphrase: %s\n"), g10_errstr(rc) );
1285         goto leave;
1286     }
1287
1288     /* We have no way to tell if the recipient can handle messages
1289        with an MDC, so this defaults to no.  Perhaps in a few years,
1290        this can be defaulted to yes.  Note that like regular
1291        encrypting, --force-mdc overrides --disable-mdc. */
1292     if(opt.force_mdc)
1293       cfx.dek->use_mdc=1;
1294
1295     /* now create the outfile */
1296     rc = open_outfile (fname, opt.armor? 1:0, &out);
1297     if (rc)
1298         goto leave;
1299
1300     /* prepare to calculate the MD over the input */
1301     if (opt.textmode)
1302         iobuf_push_filter (inp, text_filter, &tfx);
1303     mfx.md = md_open(0, 0);
1304     if ( DBG_HASHING )
1305         md_start_debug (mfx.md, "symc-sign");
1306
1307     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
1308         PKT_secret_key *sk = sk_rover->sk;
1309         md_enable (mfx.md, hash_for (sk));
1310     }
1311
1312     iobuf_push_filter (inp, md_filter, &mfx);
1313
1314     /* Push armor output filter */
1315     if (opt.armor)
1316         iobuf_push_filter (out, armor_filter, &afx);
1317
1318     /* Write the symmetric key packet */
1319     /*(current filters: armor)*/
1320     if (!RFC1991) {
1321         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1322         enc->version = 4;
1323         enc->cipher_algo = cfx.dek->algo;
1324         enc->s2k = *s2k;
1325         pkt.pkttype = PKT_SYMKEY_ENC;
1326         pkt.pkt.symkey_enc = enc;
1327         if( (rc = build_packet( out, &pkt )) )
1328             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1329         xfree(enc);
1330     }
1331
1332     /* Push the encryption filter */
1333     iobuf_push_filter( out, cipher_filter, &cfx );
1334
1335     /* Push the compress filter */
1336     if (default_compress_algo())
1337       push_compress_filter(out,&zfx,default_compress_algo());
1338
1339     /* Write the one-pass signature packets */
1340     /*(current filters: zip - encrypt - armor)*/
1341     if (!RFC1991) {
1342         rc = write_onepass_sig_packets (sk_list, out,
1343                                         opt.textmode? 0x01:0x00);
1344         if (rc)
1345             goto leave;
1346     }
1347
1348     write_status (STATUS_BEGIN_SIGNING);
1349
1350     /* Pipe data through all filters; i.e. write the signed stuff */
1351     /*(current filters: zip - encrypt - armor)*/
1352     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1353     if (rc)
1354         goto leave;
1355     
1356     /* Write the signatures */
1357     /*(current filters: zip - encrypt - armor)*/
1358     rc = write_signature_packets (sk_list, out, mfx.md,
1359                                   opt.textmode? 0x01 : 0x00,
1360                                   0, duration, 'S');
1361     if( rc )
1362         goto leave;
1363
1364
1365   leave:
1366     if( rc )
1367         iobuf_cancel(out);
1368     else {
1369         iobuf_close(out);
1370         write_status( STATUS_END_ENCRYPTION );
1371     }
1372     iobuf_close(inp);
1373     release_sk_list( sk_list );
1374     md_close( mfx.md );
1375     xfree(cfx.dek);
1376     xfree(s2k);
1377     return rc;
1378 }
1379
1380
1381 /****************
1382  * Create a signature packet for the given public key certificate and
1383  * the user id and return it in ret_sig. User signature class SIGCLASS
1384  * user-id is not used (and may be NULL if sigclass is 0x20) If
1385  * DIGEST_ALGO is 0 the function selects an appropriate one.
1386  * SIGVERSION gives the minimal required signature packet version;
1387  * this is needed so that special properties like local sign are not
1388  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1389  * the timestamp to use for the signature. 0 means "now" */
1390 int
1391 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1392                     PKT_user_id *uid, PKT_public_key *subpk,
1393                     PKT_secret_key *sk,
1394                     int sigclass, int digest_algo,
1395                     int sigversion, u32 timestamp, u32 duration,
1396                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
1397                    )
1398 {
1399     PKT_signature *sig;
1400     int rc=0;
1401     MD_HANDLE md;
1402
1403     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1404             || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1405             || sigclass == 0x30 || sigclass == 0x28 );
1406
1407     if (opt.force_v4_certs)
1408         sigversion = 4;
1409
1410     if (sigversion < sk->version)
1411         sigversion = sk->version;
1412
1413     /* If you are making a signature on a v4 key using your v3 key, it
1414        doesn't make sense to generate a v3 sig.  After all, no v3-only
1415        PGP implementation could understand the v4 key in the first
1416        place.  Note that this implies that a signature on an attribute
1417        uid is usually going to be v4 as well, since they are not
1418        generally found on v3 keys. */
1419     if (sigversion < pk->version)
1420         sigversion = pk->version;
1421
1422     if( !digest_algo )
1423       {
1424         /* Basically, this means use SHA1 always unless it's a v3 RSA
1425            key making a v3 cert (use MD5), or the user specified
1426            something (use whatever they said), or it's DSA (use the
1427            best match).  They still can't pick an inappropriate hash
1428            for DSA or the signature will fail.  Note that this still
1429            allows the caller of make_keysig_packet to override the
1430            user setting if it must. */
1431
1432         if(opt.cert_digest_algo)
1433           digest_algo=opt.cert_digest_algo;
1434         else if(sk->pubkey_algo==PUBKEY_ALGO_RSA
1435                 && pk->version<4 && sigversion<4)
1436           digest_algo = DIGEST_ALGO_MD5;
1437         else if(sk->pubkey_algo==PUBKEY_ALGO_DSA)
1438           digest_algo = match_dsa_hash(mpi_get_nbits(sk->skey[1])/8);
1439         else
1440           digest_algo = DIGEST_ALGO_SHA1;
1441       }
1442
1443     md = md_open( digest_algo, 0 );
1444
1445     /* hash the public key certificate */
1446     hash_public_key( md, pk );
1447
1448     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1449       {
1450         /* hash the subkey binding/backsig/revocation */
1451         hash_public_key( md, subpk );
1452       }
1453     else if( sigclass != 0x1F && sigclass != 0x20 )
1454       {
1455         /* hash the user id */
1456         hash_uid (md, sigversion, uid);
1457       }
1458     /* and make the signature packet */
1459     sig = xmalloc_clear( sizeof *sig );
1460     sig->version = sigversion;
1461     sig->flags.exportable=1;
1462     sig->flags.revocable=1;
1463     keyid_from_sk( sk, sig->keyid );
1464     sig->pubkey_algo = sk->pubkey_algo;
1465     sig->digest_algo = digest_algo;
1466     if(timestamp)
1467       sig->timestamp=timestamp;
1468     else
1469       sig->timestamp=make_timestamp();
1470     if(duration)
1471       sig->expiredate=sig->timestamp+duration;
1472     sig->sig_class = sigclass;
1473     if( sig->version >= 4 )
1474         build_sig_subpkt_from_sig( sig );
1475     mk_notation_policy_etc( sig, pk, sk );
1476
1477     /* Crucial that the call to mksubpkt comes LAST before the calls
1478        to finalize the sig as that makes it possible for the mksubpkt
1479        function to get a reliable pointer to the subpacket area. */
1480     if( sig->version >= 4 && mksubpkt )
1481         rc = (*mksubpkt)( sig, opaque );
1482
1483     if( !rc ) {
1484         hash_sigversion_to_magic (md, sig);
1485         md_final(md);
1486
1487         rc = complete_sig( sig, sk, md );
1488     }
1489
1490     md_close( md );
1491     if( rc )
1492         free_seckey_enc( sig );
1493     else
1494         *ret_sig = sig;
1495     return rc;
1496 }
1497
1498
1499
1500 /****************
1501  * Create a new signature packet based on an existing one.
1502  * Only user ID signatures are supported for now.
1503  * TODO: Merge this with make_keysig_packet.
1504  */
1505 int
1506 update_keysig_packet( PKT_signature **ret_sig,
1507                       PKT_signature *orig_sig,
1508                       PKT_public_key *pk,
1509                       PKT_user_id *uid, 
1510                       PKT_public_key *subpk,
1511                       PKT_secret_key *sk,
1512                       int (*mksubpkt)(PKT_signature *, void *),
1513                       void *opaque )
1514 {
1515     PKT_signature *sig;
1516     int rc=0;
1517     MD_HANDLE md;
1518
1519     if ((!orig_sig || !pk || !sk)
1520         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1521         || (orig_sig->sig_class == 0x18 && !subpk))
1522       return G10ERR_GENERAL;
1523
1524     md = md_open( orig_sig->digest_algo, 0 );
1525
1526     /* hash the public key certificate and the user id */
1527     hash_public_key( md, pk );
1528
1529     if( orig_sig->sig_class == 0x18 )
1530       hash_public_key( md, subpk );
1531     else
1532       hash_uid (md, orig_sig->version, uid);
1533
1534     /* create a new signature packet */
1535     sig = copy_signature (NULL, orig_sig);
1536  
1537     /* We need to create a new timestamp so that new sig expiration
1538        calculations are done correctly... */
1539     sig->timestamp=make_timestamp();
1540
1541     /* ... but we won't make a timestamp earlier than the existing
1542        one. */
1543     while(sig->timestamp<=orig_sig->timestamp)
1544       {
1545         sleep(1);
1546         sig->timestamp=make_timestamp();
1547       }
1548
1549     /* Note that already expired sigs will remain expired (with a
1550        duration of 1) since build-packet.c:build_sig_subpkt_from_sig
1551        detects this case. */
1552
1553     if( sig->version >= 4 )
1554       {
1555         /* Put the updated timestamp into the sig.  Note that this
1556            will automagically lower any sig expiration dates to
1557            correctly correspond to the differences in the timestamps
1558            (i.e. the duration will shrink). */
1559         build_sig_subpkt_from_sig( sig );
1560
1561         if (mksubpkt)
1562           rc = (*mksubpkt)(sig, opaque);
1563       }
1564
1565     if (!rc) {
1566         hash_sigversion_to_magic (md, sig);
1567         md_final(md);
1568
1569         rc = complete_sig( sig, sk, md );
1570     }
1571
1572     md_close (md);
1573     if( rc )
1574         free_seckey_enc (sig);
1575     else
1576         *ret_sig = sig;
1577     return rc;
1578 }