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