* sign.c (hash_for): Add code to detect if the sk lives on a smart
[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->pubkey_algo = sk->pubkey_algo;
659         if(timestamp)
660           sig->timestamp = timestamp;
661         else
662           sig->timestamp = make_timestamp();
663         if(duration)
664           sig->expiredate = sig->timestamp+duration;
665         sig->sig_class = sigclass;
666
667         md = md_copy (hash);
668
669         if (sig->version >= 4)
670             build_sig_subpkt_from_sig (sig);
671         mk_notation_policy_etc (sig, NULL, sk);
672
673         hash_sigversion_to_magic (md, sig);
674         md_final (md);
675
676         rc = do_sign( sk, sig, md, hash_for (sk) );
677         md_close (md);
678
679         if( !rc ) { /* and write it */
680             PACKET pkt;
681
682             init_packet(&pkt);
683             pkt.pkttype = PKT_SIGNATURE;
684             pkt.pkt.signature = sig;
685             rc = build_packet (out, &pkt);
686             if (!rc && is_status_enabled()) {
687                 print_status_sig_created ( sk, sig, status_letter);
688             }
689             free_packet (&pkt);
690             if (rc)
691                 log_error ("build signature packet failed: %s\n",
692                            g10_errstr(rc) );
693         }
694         if( rc )
695             return rc;;
696     }
697
698     return 0;
699 }
700
701 /****************
702  * Sign the files whose names are in FILENAME.
703  * If DETACHED has the value true,
704  * make a detached signature.  If FILENAMES->d is NULL read from stdin
705  * and ignore the detached mode.  Sign the file with all secret keys
706  * which can be taken from LOCUSR, if this is NULL, use the default one
707  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
708  * signed data for these users.
709  * If OUTFILE is not NULL; this file is used for output and the function
710  * does not ask for overwrite permission; output is then always
711  * uncompressed, non-armored and in binary mode.
712  */
713 int
714 sign_file( STRLIST filenames, int detached, STRLIST locusr,
715            int encryptflag, STRLIST remusr, const char *outfile )
716 {
717     const char *fname;
718     armor_filter_context_t afx;
719     compress_filter_context_t zfx;
720     md_filter_context_t mfx;
721     text_filter_context_t tfx;
722     progress_filter_context_t pfx;
723     encrypt_filter_context_t efx;
724     IOBUF inp = NULL, out = NULL;
725     PACKET pkt;
726     int rc = 0;
727     PK_LIST pk_list = NULL;
728     SK_LIST sk_list = NULL;
729     SK_LIST sk_rover = NULL;
730     int multifile = 0;
731     u32 duration=0;
732
733     memset( &afx, 0, sizeof afx);
734     memset( &zfx, 0, sizeof zfx);
735     memset( &mfx, 0, sizeof mfx);
736     memset( &efx, 0, sizeof efx);
737     init_packet( &pkt );
738
739     if( filenames ) {
740         fname = filenames->d;
741         multifile = !!filenames->next;
742     }
743     else
744         fname = NULL;
745
746     if( fname && filenames->next && (!detached || encryptflag) )
747         log_bug("multiple files can only be detached signed");
748
749     if(encryptflag==2
750        && (rc=setup_symkey(&efx.symkey_s2k,&efx.symkey_dek)))
751       goto leave;
752
753     if(!opt.force_v3_sigs && !RFC1991)
754       {
755         if(opt.ask_sig_expire && !opt.batch)
756           duration=ask_expire_interval(1,opt.def_sig_expire);
757         else
758           duration=parse_expire_string(opt.def_sig_expire);
759       }
760
761     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
762         goto leave;
763
764     if(PGP2 && !only_old_style(sk_list))
765       {
766         log_info(_("you can only detach-sign with PGP 2.x style keys "
767                    "while in --pgp2 mode\n"));
768         compliance_failure();
769       }
770
771     if(encryptflag && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
772       goto leave;
773
774     /* prepare iobufs */
775     if( multifile )  /* have list of filenames */
776         inp = NULL; /* we do it later */
777     else {
778       inp = iobuf_open(fname);
779       if (inp && is_secured_file (iobuf_get_fd (inp)))
780         {
781           iobuf_close (inp);
782           inp = NULL;
783           errno = EPERM;
784         }
785       if( !inp ) {
786             log_error(_("can't open `%s': %s\n"), fname? fname: "[stdin]",
787                       strerror(errno) );
788             rc = G10ERR_OPEN_FILE;
789             goto leave;
790         }
791
792         handle_progress (&pfx, inp, fname);
793     }
794
795     if( outfile ) {
796         if (is_secured_filename ( outfile )) {
797             out = NULL;
798             errno = EPERM;
799         }
800         else
801             out = iobuf_create( outfile );
802         if( !out )
803           {
804             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
805             rc = G10ERR_CREATE_FILE;
806             goto leave;
807           }
808         else if( opt.verbose )
809             log_info(_("writing to `%s'\n"), outfile );
810     }
811     else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
812         goto leave;
813
814     /* prepare to calculate the MD over the input */
815     if( opt.textmode && !outfile && !multifile )
816       {
817         memset( &tfx, 0, sizeof tfx);
818         iobuf_push_filter( inp, text_filter, &tfx );
819       }
820
821     mfx.md = md_open(0, 0);
822     if (DBG_HASHING)
823         md_start_debug (mfx.md, "sign");
824
825    /* If we're encrypting and signing, it is reasonable to pick the
826        hash algorithm to use out of the recepient key prefs. */
827     if(pk_list)
828       {
829         if(opt.def_digest_algo)
830           {
831             if(!opt.expert &&
832                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
833                                       opt.def_digest_algo,
834                                       NULL)!=opt.def_digest_algo)
835           log_info(_("WARNING: forcing digest algorithm %s (%d)"
836                      " violates recipient preferences\n"),
837                    digest_algo_to_string(opt.def_digest_algo),
838                    opt.def_digest_algo);
839           }
840         else
841           {
842             int hashlen=0,algo;
843
844             /* Of course, if the recipient asks for something
845                unreasonable (like a non-160-bit hash for DSA, for
846                example), then don't do it.  Check all sk's - if any
847                are DSA, then the hash must be 160-bit.  In the future
848                this can be more complex with different hashes for each
849                sk, but so long as there is only one signing algorithm
850                with hash restrictions, this is ok. -dms */
851
852             /* Current smartcards only do 160-bit hashes as well.
853                Note that this may well have to change as the cards add
854                algorithms. */
855
856             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
857               if(sk_rover->sk->pubkey_algo==PUBKEY_ALGO_DSA
858                  || (sk_rover->sk->is_protected
859                      && sk_rover->sk->protect.s2k.mode==1002))
860                 hashlen=20;
861
862             if((algo=
863                 select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,
864                                        hashlen?&hashlen:NULL))>0)
865               recipient_digest_algo=algo;
866           }
867       }
868
869     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
870         PKT_secret_key *sk = sk_rover->sk;
871         md_enable(mfx.md, hash_for(sk));
872     }
873
874     if( !multifile )
875         iobuf_push_filter( inp, md_filter, &mfx );
876
877     if( detached && !encryptflag && !RFC1991 )
878         afx.what = 2;
879
880     if( opt.armor && !outfile  )
881         iobuf_push_filter( out, armor_filter, &afx );
882
883     if( encryptflag ) {
884         efx.pk_list = pk_list;
885         /* fixme: set efx.cfx.datalen if known */
886         iobuf_push_filter( out, encrypt_filter, &efx );
887     }
888
889     if( opt.compress_algo && !outfile && ( !detached || opt.compress_sigs) )
890       {
891         int compr_algo=opt.compress_algo;
892
893         /* If not forced by user */
894         if(compr_algo==-1)
895           {
896             /* If we're not encrypting, then select_algo_from_prefs
897                will fail and we'll end up with the default.  If we are
898                encrypting, select_algo_from_prefs cannot fail since
899                there is an assumed preference for uncompressed data.
900                Still, if it did fail, we'll also end up with the
901                default. */
902  
903             if((compr_algo=
904                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
905               compr_algo=default_compress_algo();
906           }
907         else if(!opt.expert && pk_list
908                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
909                                           compr_algo,NULL)!=compr_algo)
910           log_info(_("WARNING: forcing compression algorithm %s (%d)"
911                      " violates recipient preferences\n"),
912                    compress_algo_to_string(compr_algo),compr_algo);
913
914         /* algo 0 means no compression */
915         if( compr_algo )
916           push_compress_filter(out,&zfx,compr_algo);
917       }
918
919     /* Write the one-pass signature packets if needed */
920     if (!detached && !RFC1991) {
921         rc = write_onepass_sig_packets (sk_list, out,
922                                         opt.textmode && !outfile ? 0x01:0x00);
923         if (rc)
924             goto leave;
925     }
926
927     /* setup the inner packet */
928     if( detached ) {
929         if( multifile ) {
930             STRLIST sl;
931
932             if( opt.verbose )
933                 log_info(_("signing:") );
934             /* must walk reverse trough this list */
935             for( sl = strlist_last(filenames); sl;
936                         sl = strlist_prev( filenames, sl ) ) {
937                 inp = iobuf_open(sl->d);
938                 if (inp && is_secured_file (iobuf_get_fd (inp)))
939                   {
940                     iobuf_close (inp);
941                     inp = NULL;
942                     errno = EPERM;
943                   }
944                 if( !inp )
945                   {
946                     log_error(_("can't open `%s': %s\n"),
947                               sl->d,strerror(errno));
948                     rc = G10ERR_OPEN_FILE;
949                     goto leave;
950                   }
951                 handle_progress (&pfx, inp, sl->d);
952                 if( opt.verbose )
953                     fprintf(stderr, " `%s'", sl->d );
954                 if(opt.textmode)
955                   {
956                     memset( &tfx, 0, sizeof tfx);
957                     iobuf_push_filter( inp, text_filter, &tfx );
958                   }
959                 iobuf_push_filter( inp, md_filter, &mfx );
960                 while( iobuf_get(inp) != -1 )
961                     ;
962                 iobuf_close(inp); inp = NULL;
963             }
964             if( opt.verbose )
965                 putc( '\n', stderr );
966         }
967         else {
968             /* read, so that the filter can calculate the digest */
969             while( iobuf_get(inp) != -1 )
970                 ;
971         }
972     }
973     else {
974         rc = write_plaintext_packet (out, inp, fname,
975                                      opt.textmode && !outfile ? 't':'b');
976     }
977
978     /* catch errors from above */
979     if (rc)
980         goto leave;
981
982     /* write the signatures */
983     rc = write_signature_packets (sk_list, out, mfx.md,
984                                   opt.textmode && !outfile? 0x01 : 0x00,
985                                   0, duration, detached ? 'D':'S');
986     if( rc )
987         goto leave;
988
989
990   leave:
991     if( rc )
992         iobuf_cancel(out);
993     else {
994         iobuf_close(out);
995         if (encryptflag)
996             write_status( STATUS_END_ENCRYPTION );
997     }
998     iobuf_close(inp);
999     md_close( mfx.md );
1000     release_sk_list( sk_list );
1001     release_pk_list( pk_list );
1002     recipient_digest_algo=0;
1003     return rc;
1004 }
1005
1006
1007
1008 /****************
1009  * make a clear signature. note that opt.armor is not needed
1010  */
1011 int
1012 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
1013 {
1014     armor_filter_context_t afx;
1015     progress_filter_context_t pfx;
1016     MD_HANDLE textmd = NULL;
1017     IOBUF inp = NULL, out = NULL;
1018     PACKET pkt;
1019     int rc = 0;
1020     SK_LIST sk_list = NULL;
1021     SK_LIST sk_rover = NULL;
1022     int old_style = RFC1991;
1023     int only_md5 = 0;
1024     u32 duration=0;
1025
1026     memset( &afx, 0, sizeof afx);
1027     init_packet( &pkt );
1028
1029     if(!opt.force_v3_sigs && !RFC1991)
1030       {
1031         if(opt.ask_sig_expire && !opt.batch)
1032           duration=ask_expire_interval(1,opt.def_sig_expire);
1033         else
1034           duration=parse_expire_string(opt.def_sig_expire);
1035       }
1036
1037     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
1038         goto leave;
1039
1040     if( !old_style && !duration )
1041         old_style = only_old_style( sk_list );
1042
1043     if(PGP2 && !only_old_style(sk_list))
1044       {
1045         log_info(_("you can only clearsign with PGP 2.x style keys "
1046                    "while in --pgp2 mode\n"));
1047         compliance_failure();
1048       }
1049
1050     /* prepare iobufs */
1051     inp = iobuf_open(fname);
1052     if (inp && is_secured_file (iobuf_get_fd (inp)))
1053       {
1054         iobuf_close (inp);
1055         inp = NULL;
1056         errno = EPERM;
1057       }
1058     if( !inp ) {
1059         log_error(_("can't open `%s': %s\n"), fname? fname: "[stdin]",
1060                                         strerror(errno) );
1061         rc = G10ERR_OPEN_FILE;
1062         goto leave;
1063     }
1064     handle_progress (&pfx, inp, fname);
1065
1066     if( outfile ) {
1067         if (is_secured_filename (outfile) ) {
1068             outfile = NULL;
1069             errno = EPERM;
1070         }
1071         else 
1072             out = iobuf_create( outfile );
1073         if( !out )
1074           {
1075             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
1076             rc = G10ERR_CREATE_FILE;
1077             goto leave;
1078           }
1079         else if( opt.verbose )
1080             log_info(_("writing to `%s'\n"), outfile );
1081     }
1082     else if( (rc = open_outfile( fname, 1, &out )) )
1083         goto leave;
1084
1085     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1086
1087     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1088         PKT_secret_key *sk = sk_rover->sk;
1089         if( hash_for(sk) == DIGEST_ALGO_MD5 )
1090             only_md5 = 1;
1091         else {
1092             only_md5 = 0;
1093             break;
1094         }
1095     }
1096
1097     if( !(old_style && only_md5) ) {
1098         const char *s;
1099         int any = 0;
1100         byte hashs_seen[256];
1101
1102         memset( hashs_seen, 0, sizeof hashs_seen );
1103         iobuf_writestr(out, "Hash: " );
1104         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1105             PKT_secret_key *sk = sk_rover->sk;
1106             int i = hash_for(sk);
1107
1108             if( !hashs_seen[ i & 0xff ] ) {
1109                 s = digest_algo_to_string( i );
1110                 if( s ) {
1111                     hashs_seen[ i & 0xff ] = 1;
1112                     if( any )
1113                         iobuf_put(out, ',' );
1114                     iobuf_writestr(out, s );
1115                     any = 1;
1116                 }
1117             }
1118         }
1119         assert(any);
1120         iobuf_writestr(out, LF );
1121     }
1122
1123     if( opt.not_dash_escaped )
1124       iobuf_writestr( out,
1125                   "NotDashEscaped: You need GnuPG to verify this message" LF );
1126     iobuf_writestr(out, LF );
1127
1128     textmd = md_open(0, 0);
1129     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1130         PKT_secret_key *sk = sk_rover->sk;
1131         md_enable(textmd, hash_for(sk));
1132     }
1133     if ( DBG_HASHING )
1134         md_start_debug( textmd, "clearsign" );
1135     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
1136                         opt.escape_from, (old_style && only_md5) );
1137     /* fixme: check for read errors */
1138
1139     /* now write the armor */
1140     afx.what = 2;
1141     iobuf_push_filter( out, armor_filter, &afx );
1142
1143     /* write the signatures */
1144     rc=write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C');
1145     if( rc )
1146         goto leave;
1147
1148   leave:
1149     if( rc )
1150         iobuf_cancel(out);
1151     else
1152         iobuf_close(out);
1153     iobuf_close(inp);
1154     md_close( textmd );
1155     release_sk_list( sk_list );
1156     return rc;
1157 }
1158
1159 /*
1160  * Sign and conventionally encrypt the given file.
1161  * FIXME: Far too much code is duplicated - revamp the whole file.
1162  */
1163 int
1164 sign_symencrypt_file (const char *fname, STRLIST locusr)
1165 {
1166     armor_filter_context_t afx;
1167     progress_filter_context_t pfx;
1168     compress_filter_context_t zfx;
1169     md_filter_context_t mfx;
1170     text_filter_context_t tfx;
1171     cipher_filter_context_t cfx;
1172     IOBUF inp = NULL, out = NULL;
1173     PACKET pkt;
1174     STRING2KEY *s2k = NULL;
1175     int rc = 0;
1176     SK_LIST sk_list = NULL;
1177     SK_LIST sk_rover = NULL;
1178     int algo;
1179     u32 duration=0;
1180
1181     memset( &afx, 0, sizeof afx);
1182     memset( &zfx, 0, sizeof zfx);
1183     memset( &mfx, 0, sizeof mfx);
1184     memset( &tfx, 0, sizeof tfx);
1185     memset( &cfx, 0, sizeof cfx);
1186     init_packet( &pkt );
1187
1188     if(!opt.force_v3_sigs && !RFC1991)
1189       {
1190         if(opt.ask_sig_expire && !opt.batch)
1191           duration=ask_expire_interval(1,opt.def_sig_expire);
1192         else
1193           duration=parse_expire_string(opt.def_sig_expire);
1194       }
1195
1196     rc = build_sk_list (locusr, &sk_list, 1, PUBKEY_USAGE_SIG);
1197     if (rc) 
1198         goto leave;
1199
1200     /* prepare iobufs */
1201     inp = iobuf_open(fname);
1202     if (inp && is_secured_file (iobuf_get_fd (inp)))
1203       {
1204         iobuf_close (inp);
1205         inp = NULL;
1206         errno = EPERM;
1207       }
1208     if( !inp ) {
1209         log_error(_("can't open `%s': %s\n"), 
1210                   fname? fname: "[stdin]", strerror(errno) );
1211         rc = G10ERR_OPEN_FILE;
1212         goto leave;
1213     }
1214     handle_progress (&pfx, inp, fname);
1215
1216     /* prepare key */
1217     s2k = xmalloc_clear( sizeof *s2k );
1218     s2k->mode = RFC1991? 0:opt.s2k_mode;
1219     s2k->hash_algo = S2K_DIGEST_ALGO;
1220
1221     algo = default_cipher_algo();
1222     if (!opt.quiet || !opt.batch)
1223         log_info (_("%s encryption will be used\n"),
1224                     cipher_algo_to_string(algo) );
1225     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, NULL);
1226
1227     if (!cfx.dek || !cfx.dek->keylen) {
1228         rc = G10ERR_PASSPHRASE;
1229         log_error(_("error creating passphrase: %s\n"), g10_errstr(rc) );
1230         goto leave;
1231     }
1232
1233     /* We have no way to tell if the recipient can handle messages
1234        with an MDC, so this defaults to no.  Perhaps in a few years,
1235        this can be defaulted to yes.  Note that like regular
1236        encrypting, --force-mdc overrides --disable-mdc. */
1237     if(opt.force_mdc)
1238       cfx.dek->use_mdc=1;
1239
1240     /* now create the outfile */
1241     rc = open_outfile (fname, opt.armor? 1:0, &out);
1242     if (rc)
1243         goto leave;
1244
1245     /* prepare to calculate the MD over the input */
1246     if (opt.textmode)
1247         iobuf_push_filter (inp, text_filter, &tfx);
1248     mfx.md = md_open(0, 0);
1249     if ( DBG_HASHING )
1250         md_start_debug (mfx.md, "symc-sign");
1251
1252     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next) {
1253         PKT_secret_key *sk = sk_rover->sk;
1254         md_enable (mfx.md, hash_for (sk));
1255     }
1256
1257     iobuf_push_filter (inp, md_filter, &mfx);
1258
1259     /* Push armor output filter */
1260     if (opt.armor)
1261         iobuf_push_filter (out, armor_filter, &afx);
1262
1263     /* Write the symmetric key packet */
1264     /*(current filters: armor)*/
1265     if (!RFC1991) {
1266         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1267         enc->version = 4;
1268         enc->cipher_algo = cfx.dek->algo;
1269         enc->s2k = *s2k;
1270         pkt.pkttype = PKT_SYMKEY_ENC;
1271         pkt.pkt.symkey_enc = enc;
1272         if( (rc = build_packet( out, &pkt )) )
1273             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1274         xfree(enc);
1275     }
1276
1277     /* Push the encryption filter */
1278     iobuf_push_filter( out, cipher_filter, &cfx );
1279
1280     /* Push the compress filter */
1281     if (default_compress_algo())
1282       push_compress_filter(out,&zfx,default_compress_algo());
1283
1284     /* Write the one-pass signature packets */
1285     /*(current filters: zip - encrypt - armor)*/
1286     if (!RFC1991) {
1287         rc = write_onepass_sig_packets (sk_list, out,
1288                                         opt.textmode? 0x01:0x00);
1289         if (rc)
1290             goto leave;
1291     }
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     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     MD_HANDLE 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                  sk->pubkey_algo==PUBKEY_ALGO_RSA_S) &&
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 }