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