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