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