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