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