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