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