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