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