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