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