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