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