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