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