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