Converted all m_free to xfree etc.
[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        
565         if( !(tmpsize = iobuf_get_filelength(inp)) )
566           log_info (_("WARNING: `%s' is an empty file\n"), fname);
567
568         /* We can't encode the length of very large files because
569            OpenPGP uses only 32 bit for file sizes.  So if the size of
570            a file is larger than 2^32 minus some bytes for packet
571            headers, we switch to partial length encoding. */
572         if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
573           filesize = tmpsize;
574         else
575           filesize = 0;
576
577         /* Because the text_filter modifies the length of the
578          * data, it is not possible to know the used length
579          * without a double read of the file - to avoid that
580          * we simple use partial length packets. */
581         if ( ptmode == 't' )
582           filesize = 0;
583       }
584     else
585       filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
586
587     if (!opt.no_literal) {
588         PACKET pkt;
589
590         pt->timestamp = make_timestamp ();
591         pt->mode = ptmode;
592         pt->len = filesize;
593         pt->new_ctb = !pt->len && !RFC1991;
594         pt->buf = inp;
595         init_packet(&pkt);
596         pkt.pkttype = PKT_PLAINTEXT;
597         pkt.pkt.plaintext = pt;
598         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
599         if( (rc = build_packet (out, &pkt)) )
600             log_error ("build_packet(PLAINTEXT) failed: %s\n",
601                        g10_errstr(rc) );
602         pt->buf = NULL;
603     }
604     else {
605         byte copy_buffer[4096];
606         int  bytes_copied;
607
608         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
609             if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
610                 rc = G10ERR_WRITE_FILE;
611                 log_error ("copying input to output failed: %s\n",
612                            g10_errstr(rc));
613                 break;
614             }
615         wipememory(copy_buffer,4096); /* burn buffer */
616     }
617     /* fixme: it seems that we never freed pt/pkt */
618     
619     return rc;
620 }
621
622 /*
623  * Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
624  * hash which will not be changes here.
625  */
626 static int
627 write_signature_packets (SK_LIST sk_list, IOBUF out, MD_HANDLE hash,
628                          int sigclass, u32 timestamp, u32 duration,
629                          int status_letter)
630 {
631     SK_LIST sk_rover;
632
633     /* loop over the secret certificates */
634     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
635         PKT_secret_key *sk;
636         PKT_signature *sig;
637         MD_HANDLE md;
638         int rc;
639
640         sk = sk_rover->sk;
641
642         /* build the signature packet */
643         sig = xmalloc_clear (sizeof *sig);
644         if(opt.force_v3_sigs || RFC1991)
645           sig->version=3;
646         else if(duration || opt.sig_policy_url
647                 || opt.sig_notation_data || opt.sig_keyserver_url)
648           sig->version=4;
649         else
650           sig->version=sk->version;
651         keyid_from_sk (sk, sig->keyid);
652         sig->digest_algo = hash_for (sk->pubkey_algo, sk->version);
653         sig->pubkey_algo = sk->pubkey_algo;
654         if(timestamp)
655           sig->timestamp = timestamp;
656         else
657           sig->timestamp = make_timestamp();
658         if(duration)
659           sig->expiredate = sig->timestamp+duration;
660         sig->sig_class = sigclass;
661
662         md = md_copy (hash);
663
664         if (sig->version >= 4)
665             build_sig_subpkt_from_sig (sig);
666         mk_notation_policy_etc (sig, NULL, sk);
667
668         hash_sigversion_to_magic (md, sig);
669         md_final (md);
670
671         rc = do_sign( sk, sig, md, hash_for (sig->pubkey_algo, sk->version) );
672         md_close (md);
673
674         if( !rc ) { /* and write it */
675             PACKET pkt;
676
677             init_packet(&pkt);
678             pkt.pkttype = PKT_SIGNATURE;
679             pkt.pkt.signature = sig;
680             rc = build_packet (out, &pkt);
681             if (!rc && is_status_enabled()) {
682                 print_status_sig_created ( sk, sig, status_letter);
683             }
684             free_packet (&pkt);
685             if (rc)
686                 log_error ("build signature packet failed: %s\n",
687                            g10_errstr(rc) );
688         }
689         if( rc )
690             return rc;;
691     }
692
693     return 0;
694 }
695
696 /****************
697  * Sign the files whose names are in FILENAME.
698  * If DETACHED has the value true,
699  * make a detached signature.  If FILENAMES->d is NULL read from stdin
700  * and ignore the detached mode.  Sign the file with all secret keys
701  * which can be taken from LOCUSR, if this is NULL, use the default one
702  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
703  * signed data for these users.
704  * If OUTFILE is not NULL; this file is used for output and the function
705  * does not ask for overwrite permission; output is then always
706  * uncompressed, non-armored and in binary mode.
707  */
708 int
709 sign_file( STRLIST filenames, int detached, STRLIST locusr,
710            int encryptflag, STRLIST remusr, const char *outfile )
711 {
712     const char *fname;
713     armor_filter_context_t afx;
714     compress_filter_context_t zfx;
715     md_filter_context_t mfx;
716     text_filter_context_t tfx;
717     progress_filter_context_t pfx;
718     encrypt_filter_context_t efx;
719     IOBUF inp = NULL, out = NULL;
720     PACKET pkt;
721     int rc = 0;
722     PK_LIST pk_list = NULL;
723     SK_LIST sk_list = NULL;
724     SK_LIST sk_rover = NULL;
725     int multifile = 0;
726     u32 duration=0;
727
728     memset( &afx, 0, sizeof afx);
729     memset( &zfx, 0, sizeof zfx);
730     memset( &mfx, 0, sizeof mfx);
731     memset( &efx, 0, sizeof efx);
732     init_packet( &pkt );
733
734     if( filenames ) {
735         fname = filenames->d;
736         multifile = !!filenames->next;
737     }
738     else
739         fname = NULL;
740
741     if( fname && filenames->next && (!detached || encryptflag) )
742         log_bug("multiple files can only be detached signed");
743
744     if(encryptflag==2
745        && (rc=setup_symkey(&efx.symkey_s2k,&efx.symkey_dek)))
746       goto leave;
747
748     if(!opt.force_v3_sigs && !RFC1991)
749       {
750         if(opt.ask_sig_expire && !opt.batch)
751           duration=ask_expire_interval(1,opt.def_sig_expire);
752         else
753           duration=parse_expire_string(opt.def_sig_expire);
754       }
755
756     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
757         goto leave;
758
759     if(PGP2 && !only_old_style(sk_list))
760       {
761         log_info(_("you can only detach-sign with PGP 2.x style keys "
762                    "while in --pgp2 mode\n"));
763         compliance_failure();
764       }
765
766     if(encryptflag && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
767       goto leave;
768
769     /* prepare iobufs */
770     if( multifile )  /* have list of filenames */
771         inp = NULL; /* we do it later */
772     else {
773       inp = iobuf_open(fname);
774       if (inp && is_secured_file (iobuf_get_fd (inp)))
775         {
776           iobuf_close (inp);
777           inp = NULL;
778           errno = EPERM;
779         }
780       if( !inp ) {
781             log_error(_("can't open `%s': %s\n"), fname? fname: "[stdin]",
782                       strerror(errno) );
783             rc = G10ERR_OPEN_FILE;
784             goto leave;
785         }
786
787         handle_progress (&pfx, inp, fname);
788     }
789
790     if( outfile ) {
791         if (is_secured_filename ( outfile )) {
792             out = NULL;
793             errno = EPERM;
794         }
795         else
796             out = iobuf_create( outfile );
797         if( !out )
798           {
799             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
800             rc = G10ERR_CREATE_FILE;
801             goto leave;
802           }
803         else if( opt.verbose )
804             log_info(_("writing to `%s'\n"), outfile );
805     }
806     else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
807         goto leave;
808
809     /* prepare to calculate the MD over the input */
810     if( opt.textmode && !outfile && !multifile )
811       {
812         memset( &tfx, 0, sizeof tfx);
813         iobuf_push_filter( inp, text_filter, &tfx );
814       }
815
816     mfx.md = md_open(0, 0);
817     if (DBG_HASHING)
818         md_start_debug (mfx.md, "sign");
819
820    /* If we're encrypting and signing, it is reasonable to pick the
821        hash algorithm to use out of the recepient key prefs. */
822     if(pk_list)
823       {
824         if(opt.def_digest_algo)
825           {
826             if(!opt.expert &&
827                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
828                                       opt.def_digest_algo,
829                                       NULL)!=opt.def_digest_algo)
830           log_info(_("WARNING: forcing digest algorithm %s (%d)"
831                      " violates recipient preferences\n"),
832                    digest_algo_to_string(opt.def_digest_algo),
833                    opt.def_digest_algo);
834           }
835         else
836           {
837             int hashlen=0,algo;
838
839             /* Of course, if the recipient asks for something
840                unreasonable (like a non-160-bit hash for DSA, for
841                example), then don't do it.  Check all sk's - if any
842                are DSA, then the hash must be 160-bit.  In the future
843                this can be more complex with different hashes for each
844                sk, but so long as there is only one signing algorithm
845                with hash restrictions, this is ok. -dms */
846
847             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
848               if(sk_rover->sk->pubkey_algo==PUBKEY_ALGO_DSA)
849                 hashlen=20;
850
851             if((algo=
852                 select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,
853                                        hashlen?&hashlen:NULL))>0)
854               recipient_digest_algo=algo;
855           }
856       }
857
858     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
859         PKT_secret_key *sk = sk_rover->sk;
860         md_enable(mfx.md, hash_for(sk->pubkey_algo, sk->version ));
861     }
862
863     if( !multifile )
864         iobuf_push_filter( inp, md_filter, &mfx );
865
866     if( detached && !encryptflag && !RFC1991 )
867         afx.what = 2;
868
869     if( opt.armor && !outfile  )
870         iobuf_push_filter( out, armor_filter, &afx );
871
872     if( encryptflag ) {
873         efx.pk_list = pk_list;
874         /* fixme: set efx.cfx.datalen if known */
875         iobuf_push_filter( out, encrypt_filter, &efx );
876     }
877
878     if( opt.compress_algo && !outfile && ( !detached || opt.compress_sigs) )
879       {
880         int compr_algo=opt.compress_algo;
881
882         /* If not forced by user */
883         if(compr_algo==-1)
884           {
885             /* If we're not encrypting, then select_algo_from_prefs
886                will fail and we'll end up with the default.  If we are
887                encrypting, select_algo_from_prefs cannot fail since
888                there is an assumed preference for uncompressed data.
889                Still, if it did fail, we'll also end up with the
890                default. */
891  
892             if((compr_algo=
893                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
894               compr_algo=default_compress_algo();
895           }
896         else if(!opt.expert && pk_list
897                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
898                                           compr_algo,NULL)!=compr_algo)
899           log_info(_("WARNING: forcing compression algorithm %s (%d)"
900                      " violates recipient preferences\n"),
901                    compress_algo_to_string(compr_algo),compr_algo);
902
903         /* algo 0 means no compression */
904         if( compr_algo )
905           push_compress_filter(out,&zfx,compr_algo);
906       }
907
908     /* Write the one-pass signature packets if needed */
909     if (!detached && !RFC1991) {
910         rc = write_onepass_sig_packets (sk_list, out,
911                                         opt.textmode && !outfile ? 0x01:0x00);
912         if (rc)
913             goto leave;
914     }
915
916     /* setup the inner packet */
917     if( detached ) {
918         if( multifile ) {
919             STRLIST sl;
920
921             if( opt.verbose )
922                 log_info(_("signing:") );
923             /* must walk reverse trough this list */
924             for( sl = strlist_last(filenames); sl;
925                         sl = strlist_prev( filenames, sl ) ) {
926                 inp = iobuf_open(sl->d);
927                 if (inp && is_secured_file (iobuf_get_fd (inp)))
928                   {
929                     iobuf_close (inp);
930                     inp = NULL;
931                     errno = EPERM;
932                   }
933                 if( !inp )
934                   {
935                     log_error(_("can't open `%s': %s\n"),
936                               sl->d,strerror(errno));
937                     rc = G10ERR_OPEN_FILE;
938                     goto leave;
939                   }
940                 handle_progress (&pfx, inp, sl->d);
941                 if( opt.verbose )
942                     fprintf(stderr, " `%s'", sl->d );
943                 if(opt.textmode)
944                   {
945                     memset( &tfx, 0, sizeof tfx);
946                     iobuf_push_filter( inp, text_filter, &tfx );
947                   }
948                 iobuf_push_filter( inp, md_filter, &mfx );
949                 while( iobuf_get(inp) != -1 )
950                     ;
951                 iobuf_close(inp); inp = NULL;
952             }
953             if( opt.verbose )
954                 putc( '\n', stderr );
955         }
956         else {
957             /* read, so that the filter can calculate the digest */
958             while( iobuf_get(inp) != -1 )
959                 ;
960         }
961     }
962     else {
963         rc = write_plaintext_packet (out, inp, fname,
964                                      opt.textmode && !outfile ? 't':'b');
965     }
966
967     /* catch errors from above */
968     if (rc)
969         goto leave;
970
971     /* write the signatures */
972     rc = write_signature_packets (sk_list, out, mfx.md,
973                                   opt.textmode && !outfile? 0x01 : 0x00,
974                                   0, duration, detached ? 'D':'S');
975     if( rc )
976         goto leave;
977
978
979   leave:
980     if( rc )
981         iobuf_cancel(out);
982     else {
983         iobuf_close(out);
984         if (encryptflag)
985             write_status( STATUS_END_ENCRYPTION );
986     }
987     iobuf_close(inp);
988     md_close( mfx.md );
989     release_sk_list( sk_list );
990     release_pk_list( pk_list );
991     recipient_digest_algo=0;
992     return rc;
993 }
994
995
996
997 /****************
998  * make a clear signature. note that opt.armor is not needed
999  */
1000 int
1001 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
1002 {
1003     armor_filter_context_t afx;
1004     progress_filter_context_t pfx;
1005     MD_HANDLE textmd = NULL;
1006     IOBUF inp = NULL, out = NULL;
1007     PACKET pkt;
1008     int rc = 0;
1009     SK_LIST sk_list = NULL;
1010     SK_LIST sk_rover = NULL;
1011     int old_style = RFC1991;
1012     int only_md5 = 0;
1013     u32 duration=0;
1014
1015     memset( &afx, 0, sizeof afx);
1016     init_packet( &pkt );
1017
1018     if(!opt.force_v3_sigs && !RFC1991)
1019       {
1020         if(opt.ask_sig_expire && !opt.batch)
1021           duration=ask_expire_interval(1,opt.def_sig_expire);
1022         else
1023           duration=parse_expire_string(opt.def_sig_expire);
1024       }
1025
1026     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
1027         goto leave;
1028
1029     if( !old_style && !duration )
1030         old_style = only_old_style( sk_list );
1031
1032     if(PGP2 && !only_old_style(sk_list))
1033       {
1034         log_info(_("you can only clearsign with PGP 2.x style keys "
1035                    "while in --pgp2 mode\n"));
1036         compliance_failure();
1037       }
1038
1039     /* prepare iobufs */
1040     inp = iobuf_open(fname);
1041     if (inp && is_secured_file (iobuf_get_fd (inp)))
1042       {
1043         iobuf_close (inp);
1044         inp = NULL;
1045         errno = EPERM;
1046       }
1047     if( !inp ) {
1048         log_error(_("can't open `%s': %s\n"), fname? fname: "[stdin]",
1049                                         strerror(errno) );
1050         rc = G10ERR_OPEN_FILE;
1051         goto leave;
1052     }
1053     handle_progress (&pfx, inp, fname);
1054
1055     if( outfile ) {
1056         if (is_secured_filename (outfile) ) {
1057             outfile = NULL;
1058             errno = EPERM;
1059         }
1060         else 
1061             out = iobuf_create( outfile );
1062         if( !out )
1063           {
1064             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
1065             rc = G10ERR_CREATE_FILE;
1066             goto leave;
1067           }
1068         else if( opt.verbose )
1069             log_info(_("writing to `%s'\n"), outfile );
1070     }
1071     else if( (rc = open_outfile( fname, 1, &out )) )
1072         goto leave;
1073
1074     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1075
1076     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1077         PKT_secret_key *sk = sk_rover->sk;
1078         if( hash_for(sk->pubkey_algo, sk->version) == DIGEST_ALGO_MD5 )
1079             only_md5 = 1;
1080         else {
1081             only_md5 = 0;
1082             break;
1083         }
1084     }
1085
1086     if( !(old_style && only_md5) ) {
1087         const char *s;
1088         int any = 0;
1089         byte hashs_seen[256];
1090
1091         memset( hashs_seen, 0, sizeof hashs_seen );
1092         iobuf_writestr(out, "Hash: " );
1093         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1094             PKT_secret_key *sk = sk_rover->sk;
1095             int i = hash_for(sk->pubkey_algo, sk->version);
1096
1097             if( !hashs_seen[ i & 0xff ] ) {
1098                 s = digest_algo_to_string( i );
1099                 if( s ) {
1100                     hashs_seen[ i & 0xff ] = 1;
1101                     if( any )
1102                         iobuf_put(out, ',' );
1103                     iobuf_writestr(out, s );
1104                     any = 1;
1105                 }
1106             }
1107         }
1108         assert(any);
1109         iobuf_writestr(out, LF );
1110     }
1111
1112     if( opt.not_dash_escaped )
1113       iobuf_writestr( out,
1114                   "NotDashEscaped: You need GnuPG to verify this message" LF );
1115     iobuf_writestr(out, LF );
1116
1117     textmd = md_open(0, 0);
1118     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1119         PKT_secret_key *sk = sk_rover->sk;
1120         md_enable(textmd, hash_for(sk->pubkey_algo, sk->version));
1121     }
1122     if ( DBG_HASHING )
1123         md_start_debug( textmd, "clearsign" );
1124     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
1125                         opt.escape_from, (old_style && only_md5) );
1126     /* fixme: check for read errors */
1127
1128     /* now write the armor */
1129     afx.what = 2;
1130     iobuf_push_filter( out, armor_filter, &afx );
1131
1132     /* write the signatures */
1133     rc=write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C');
1134     if( rc )
1135         goto leave;
1136
1137   leave:
1138     if( rc )
1139         iobuf_cancel(out);
1140     else
1141         iobuf_close(out);
1142     iobuf_close(inp);
1143     md_close( textmd );
1144     release_sk_list( sk_list );
1145     return rc;
1146 }
1147
1148 /*
1149  * Sign and conventionally encrypt the given file.
1150  * FIXME: Far too much code is duplicated - revamp the whole file.
1151  */
1152 int
1153 sign_symencrypt_file (const char *fname, STRLIST locusr)
1154 {
1155     armor_filter_context_t afx;
1156     progress_filter_context_t pfx;
1157     compress_filter_context_t zfx;
1158     md_filter_context_t mfx;
1159     text_filter_context_t tfx;
1160     cipher_filter_context_t cfx;
1161     IOBUF inp = NULL, out = NULL;
1162     PACKET pkt;
1163     STRING2KEY *s2k = NULL;
1164     int rc = 0;
1165     SK_LIST sk_list = NULL;
1166     SK_LIST sk_rover = NULL;
1167     int algo;
1168     u32 duration=0;
1169
1170     memset( &afx, 0, sizeof afx);
1171     memset( &zfx, 0, sizeof zfx);
1172     memset( &mfx, 0, sizeof mfx);
1173     memset( &tfx, 0, sizeof tfx);
1174     memset( &cfx, 0, sizeof cfx);
1175     init_packet( &pkt );
1176
1177     if(!opt.force_v3_sigs && !RFC1991)
1178       {
1179         if(opt.ask_sig_expire && !opt.batch)
1180           duration=ask_expire_interval(1,opt.def_sig_expire);
1181         else
1182           duration=parse_expire_string(opt.def_sig_expire);
1183       }
1184
1185     rc = build_sk_list (locusr, &sk_list, 1, PUBKEY_USAGE_SIG);
1186     if (rc) 
1187         goto leave;
1188
1189     /* prepare iobufs */
1190     inp = iobuf_open(fname);
1191     if (inp && is_secured_file (iobuf_get_fd (inp)))
1192       {
1193         iobuf_close (inp);
1194         inp = NULL;
1195         errno = EPERM;
1196       }
1197     if( !inp ) {
1198         log_error(_("can't open `%s': %s\n"), 
1199                   fname? fname: "[stdin]", strerror(errno) );
1200         rc = G10ERR_OPEN_FILE;
1201         goto leave;
1202     }
1203     handle_progress (&pfx, inp, fname);
1204
1205     /* prepare key */
1206     s2k = xmalloc_clear( sizeof *s2k );
1207     s2k->mode = RFC1991? 0:opt.s2k_mode;
1208     s2k->hash_algo = S2K_DIGEST_ALGO;
1209
1210     algo = default_cipher_algo();
1211     if (!opt.quiet || !opt.batch)
1212         log_info (_("%s encryption will be used\n"),
1213                     cipher_algo_to_string(algo) );
1214     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, NULL);
1215
1216     if (!cfx.dek || !cfx.dek->keylen) {
1217         rc = G10ERR_PASSPHRASE;
1218         log_error(_("error creating passphrase: %s\n"), g10_errstr(rc) );
1219         goto leave;
1220     }
1221
1222     /* We have no way to tell if the recipient can handle messages
1223        with an MDC, so this defaults to no.  Perhaps in a few years,
1224        this can be defaulted to yes.  Note that like regular
1225        encrypting, --force-mdc overrides --disable-mdc. */
1226     if(opt.force_mdc)
1227       cfx.dek->use_mdc=1;
1228
1229     /* now create the outfile */
1230     rc = open_outfile (fname, opt.armor? 1:0, &out);
1231     if (rc)
1232         goto leave;
1233
1234     /* prepare to calculate the MD over the input */
1235     if (opt.textmode)
1236         iobuf_push_filter (inp, text_filter, &tfx);
1237     mfx.md = md_open(0, 0);
1238     if ( DBG_HASHING )
1239         md_start_debug (mfx.md, "symc-sign");
1240
1241     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
1242         PKT_secret_key *sk = sk_rover->sk;
1243         md_enable (mfx.md, hash_for (sk->pubkey_algo, sk->version ));
1244     }
1245
1246     iobuf_push_filter (inp, md_filter, &mfx);
1247
1248     /* Push armor output filter */
1249     if (opt.armor)
1250         iobuf_push_filter (out, armor_filter, &afx);
1251
1252     /* Write the symmetric key packet */
1253     /*(current filters: armor)*/
1254     if (!RFC1991) {
1255         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1256         enc->version = 4;
1257         enc->cipher_algo = cfx.dek->algo;
1258         enc->s2k = *s2k;
1259         pkt.pkttype = PKT_SYMKEY_ENC;
1260         pkt.pkt.symkey_enc = enc;
1261         if( (rc = build_packet( out, &pkt )) )
1262             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1263         xfree(enc);
1264     }
1265
1266     /* Push the encryption filter */
1267     iobuf_push_filter( out, cipher_filter, &cfx );
1268
1269     /* Push the compress filter */
1270     if (default_compress_algo())
1271       push_compress_filter(out,&zfx,default_compress_algo());
1272
1273     /* Write the one-pass signature packets */
1274     /*(current filters: zip - encrypt - armor)*/
1275     if (!RFC1991) {
1276         rc = write_onepass_sig_packets (sk_list, out,
1277                                         opt.textmode? 0x01:0x00);
1278         if (rc)
1279             goto leave;
1280     }
1281
1282     /* Pipe data through all filters; i.e. write the signed stuff */
1283     /*(current filters: zip - encrypt - armor)*/
1284     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1285     if (rc)
1286         goto leave;
1287     
1288     /* Write the signatures */
1289     /*(current filters: zip - encrypt - armor)*/
1290     rc = write_signature_packets (sk_list, out, mfx.md,
1291                                   opt.textmode? 0x01 : 0x00,
1292                                   0, duration, 'S');
1293     if( rc )
1294         goto leave;
1295
1296
1297   leave:
1298     if( rc )
1299         iobuf_cancel(out);
1300     else {
1301         iobuf_close(out);
1302         write_status( STATUS_END_ENCRYPTION );
1303     }
1304     iobuf_close(inp);
1305     release_sk_list( sk_list );
1306     md_close( mfx.md );
1307     xfree(cfx.dek);
1308     xfree(s2k);
1309     return rc;
1310 }
1311
1312
1313 /****************
1314  * Create a signature packet for the given public key certificate and
1315  * the user id and return it in ret_sig. User signature class SIGCLASS
1316  * user-id is not used (and may be NULL if sigclass is 0x20) If
1317  * DIGEST_ALGO is 0 the function selects an appropriate one.
1318  * SIGVERSION gives the minimal required signature packet version;
1319  * this is needed so that special properties like local sign are not
1320  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1321  * the timestamp to use for the signature. 0 means "now" */
1322 int
1323 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1324                     PKT_user_id *uid, PKT_public_key *subpk,
1325                     PKT_secret_key *sk,
1326                     int sigclass, int digest_algo,
1327                     int sigversion, u32 timestamp, u32 duration,
1328                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
1329                    )
1330 {
1331     PKT_signature *sig;
1332     int rc=0;
1333     MD_HANDLE md;
1334
1335     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1336             || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1337             || sigclass == 0x30 || sigclass == 0x28 );
1338
1339     if (opt.force_v4_certs)
1340         sigversion = 4;
1341
1342     if (sigversion < sk->version)
1343         sigversion = sk->version;
1344
1345     /* If you are making a signature on a v4 key using your v3 key, it
1346        doesn't make sense to generate a v3 sig.  After all, no v3-only
1347        PGP implementation could understand the v4 key in the first
1348        place.  Note that this implies that a signature on an attribute
1349        uid is usually going to be v4 as well, since they are not
1350        generally found on v3 keys. */
1351     if (sigversion < pk->version)
1352         sigversion = pk->version;
1353
1354     if( !digest_algo )
1355       {
1356         /* Basically, this means use SHA1 always unless it's a v3 RSA
1357            key making a v3 cert (use MD5), or the user specified
1358            something (use whatever they said).  They still must use a
1359            160-bit hash with DSA, or the signature will fail.  Note
1360            that this still allows the caller of make_keysig_packet to
1361            override the user setting if it must. */
1362
1363         if(opt.cert_digest_algo)
1364           digest_algo=opt.cert_digest_algo;
1365         else if((sk->pubkey_algo==PUBKEY_ALGO_RSA ||
1366                  sk->pubkey_algo==PUBKEY_ALGO_RSA_S) &&
1367                 pk->version<4 && sigversion < 4)
1368           digest_algo = DIGEST_ALGO_MD5;
1369         else
1370           digest_algo = DIGEST_ALGO_SHA1;
1371       }
1372
1373     md = md_open( digest_algo, 0 );
1374
1375     /* hash the public key certificate */
1376     hash_public_key( md, pk );
1377
1378     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1379       {
1380         /* hash the subkey binding/backsig/revocation */
1381         hash_public_key( md, subpk );
1382       }
1383     else if( sigclass != 0x1F && sigclass != 0x20 )
1384       {
1385         /* hash the user id */
1386         hash_uid (md, sigversion, uid);
1387       }
1388     /* and make the signature packet */
1389     sig = xmalloc_clear( sizeof *sig );
1390     sig->version = sigversion;
1391     sig->flags.exportable=1;
1392     sig->flags.revocable=1;
1393     keyid_from_sk( sk, sig->keyid );
1394     sig->pubkey_algo = sk->pubkey_algo;
1395     sig->digest_algo = digest_algo;
1396     if(timestamp)
1397       sig->timestamp=timestamp;
1398     else
1399       sig->timestamp=make_timestamp();
1400     if(duration)
1401       sig->expiredate=sig->timestamp+duration;
1402     sig->sig_class = sigclass;
1403     if( sig->version >= 4 )
1404         build_sig_subpkt_from_sig( sig );
1405     mk_notation_policy_etc( sig, pk, sk );
1406
1407     /* Crucial that the call to mksubpkt comes LAST before the calls
1408        to finalize the sig as that makes it possible for the mksubpkt
1409        function to get a reliable pointer to the subpacket area. */
1410     if( sig->version >= 4 && mksubpkt )
1411         rc = (*mksubpkt)( sig, opaque );
1412
1413     if( !rc ) {
1414         hash_sigversion_to_magic (md, sig);
1415         md_final(md);
1416
1417         rc = complete_sig( sig, sk, md );
1418     }
1419
1420     md_close( md );
1421     if( rc )
1422         free_seckey_enc( sig );
1423     else
1424         *ret_sig = sig;
1425     return rc;
1426 }
1427
1428
1429
1430 /****************
1431  * Create a new signature packet based on an existing one.
1432  * Only user ID signatures are supported for now.
1433  * TODO: Merge this with make_keysig_packet.
1434  */
1435 int
1436 update_keysig_packet( PKT_signature **ret_sig,
1437                       PKT_signature *orig_sig,
1438                       PKT_public_key *pk,
1439                       PKT_user_id *uid, 
1440                       PKT_public_key *subpk,
1441                       PKT_secret_key *sk,
1442                       int (*mksubpkt)(PKT_signature *, void *),
1443                       void *opaque )
1444 {
1445     PKT_signature *sig;
1446     int rc=0;
1447     MD_HANDLE md;
1448
1449     if ((!orig_sig || !pk || !sk)
1450         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1451         || (orig_sig->sig_class == 0x18 && !subpk))
1452       return G10ERR_GENERAL;
1453
1454     md = md_open( orig_sig->digest_algo, 0 );
1455
1456     /* hash the public key certificate and the user id */
1457     hash_public_key( md, pk );
1458
1459     if( orig_sig->sig_class == 0x18 )
1460       hash_public_key( md, subpk );
1461     else
1462       hash_uid (md, orig_sig->version, uid);
1463
1464     /* create a new signature packet */
1465     sig = copy_signature (NULL, orig_sig);
1466  
1467     /* We need to create a new timestamp so that new sig expiration
1468        calculations are done correctly... */
1469     sig->timestamp=make_timestamp();
1470
1471     /* ... but we won't make a timestamp earlier than the existing
1472        one. */
1473     while(sig->timestamp<=orig_sig->timestamp)
1474       {
1475         sleep(1);
1476         sig->timestamp=make_timestamp();
1477       }
1478
1479     /* Note that already expired sigs will remain expired (with a
1480        duration of 0) since build-packet.c:build_sig_subpkt_from_sig
1481        detects this case. */
1482
1483     if( sig->version >= 4 )
1484       {
1485         /* Put the updated timestamp into the sig.  Note that this
1486            will automagically lower any sig expiration dates to
1487            correctly correspond to the differences in the timestamps
1488            (i.e. the duration will shrink). */
1489         build_sig_subpkt_from_sig( sig );
1490
1491         if (mksubpkt)
1492           rc = (*mksubpkt)(sig, opaque);
1493       }
1494
1495     if (!rc) {
1496         hash_sigversion_to_magic (md, sig);
1497         md_final(md);
1498
1499         rc = complete_sig( sig, sk, md );
1500     }
1501
1502     md_close (md);
1503     if( rc )
1504         free_seckey_enc (sig);
1505     else
1506         *ret_sig = sig;
1507     return rc;
1508 }