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