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