d06a9cc5f38b548ee874dd2a8b13177a2c9e824f
[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 (0 
425            /* FIXME: call agent sk->is_protected && sk->protect.s2k.mode == 1002
426            && sk->protect.ivlen == 16
427            && !memcmp (sk->protect.iv, "\xD2\x76\x00\x01\x24\x01\x01", 7)*/)
428     {
429       /* The sk lives on a smartcard, and old smartcards only handle
430          SHA-1 and RIPEMD/160.  Newer smartcards (v2.0) don't have
431          this restriction anymore.  Fortunately the serial number
432          encodes the version of the card and thus we know that this
433          key is on a v1 card. */
434       if(opt.personal_digest_prefs)
435         {
436           prefitem_t *prefs;
437
438           for (prefs=opt.personal_digest_prefs;prefs->type;prefs++)
439             if (prefs->value==DIGEST_ALGO_SHA1
440                 || prefs->value==DIGEST_ALGO_RMD160)
441               return prefs->value;
442         }
443
444       return DIGEST_ALGO_SHA1;
445     }
446   else if (PGP2 && pk->pubkey_algo == PUBKEY_ALGO_RSA && pk->version < 4 )
447     {
448       /* Old-style PGP only understands MD5 */
449       return DIGEST_ALGO_MD5;
450     }
451   else if (opt.personal_digest_prefs)
452     {
453       /* It's not DSA, so we can use whatever the first hash algorithm
454          is in the pref list */
455       return opt.personal_digest_prefs[0].value;
456     }
457   else
458     return DEFAULT_DIGEST_ALGO;
459 }
460
461
462 /* Return true iff all keys in SK_LIST are old style (v3 RSA).  */
463 static int
464 only_old_style (SK_LIST sk_list)
465 {
466   SK_LIST sk_rover = NULL;
467   int old_style = 0;
468   
469   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
470     {
471       PKT_public_key *pk = sk_rover->pk;
472
473       if (pk->pubkey_algo == PUBKEY_ALGO_RSA && pk->version < 4)
474         old_style = 1;
475       else
476         return 0;
477     }
478   return old_style;
479 }
480
481
482 static void
483 print_status_sig_created (PKT_public_key *pk, PKT_signature *sig, int what)
484 {
485   byte array[MAX_FINGERPRINT_LEN];
486   char buf[100+MAX_FINGERPRINT_LEN*2];
487   size_t n;
488   
489   snprintf (buf, sizeof buf - 2*MAX_FINGERPRINT_LEN, "%c %d %d %02x %lu ",
490             what, sig->pubkey_algo, sig->digest_algo, sig->sig_class,
491             (ulong)sig->timestamp );
492   fingerprint_from_pk (pk, array, &n);
493   bin2hex (array, n, buf + strlen (buf));
494   
495   write_status_text( STATUS_SIG_CREATED, buf );
496 }
497
498
499 /*
500  * Loop over the secret certificates in SK_LIST and build the one pass
501  * signature packets.  OpenPGP says that the data should be bracket by
502  * the onepass-sig and signature-packet; so we build these onepass
503  * packet here in reverse order 
504  */
505 static int
506 write_onepass_sig_packets (SK_LIST sk_list, IOBUF out, int sigclass )
507 {
508     int skcount;
509     SK_LIST sk_rover;
510
511     for (skcount=0, sk_rover=sk_list; sk_rover; sk_rover = sk_rover->next)
512         skcount++;
513
514     for (; skcount; skcount--) {
515         PKT_public_key *pk;
516         PKT_onepass_sig *ops;
517         PACKET pkt;
518         int i, rc;
519         
520         for (i=0, sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
521             if (++i == skcount)
522                 break;
523         }
524
525         pk = sk_rover->pk;
526         ops = xmalloc_clear (sizeof *ops);
527         ops->sig_class = sigclass;
528         ops->digest_algo = hash_for (pk);
529         ops->pubkey_algo = pk->pubkey_algo;
530         keyid_from_pk (pk, ops->keyid);
531         ops->last = (skcount == 1);
532         
533         init_packet(&pkt);
534         pkt.pkttype = PKT_ONEPASS_SIG;
535         pkt.pkt.onepass_sig = ops;
536         rc = build_packet (out, &pkt);
537         free_packet (&pkt);
538         if (rc) {
539             log_error ("build onepass_sig packet failed: %s\n",
540                        g10_errstr(rc));
541             return rc;
542         }
543     }
544
545     return 0;
546 }
547
548 /*
549  * Helper to write the plaintext (literal data) packet
550  */
551 static int
552 write_plaintext_packet (IOBUF out, IOBUF inp, const char *fname, int ptmode)
553 {
554     PKT_plaintext *pt = NULL;
555     u32 filesize;
556     int rc = 0;
557
558     if (!opt.no_literal)
559       pt=setup_plaintext_name(fname,inp);
560
561     /* try to calculate the length of the data */
562     if ( !iobuf_is_pipe_filename (fname) && *fname )
563       {
564         off_t tmpsize;
565         int overflow;
566
567         if( !(tmpsize = iobuf_get_filelength(inp, &overflow))
568             && !overflow && opt.verbose)
569           log_info (_("WARNING: `%s' is an empty file\n"), fname);
570
571         /* We can't encode the length of very large files because
572            OpenPGP uses only 32 bit for file sizes.  So if the size of
573            a file is larger than 2^32 minus some bytes for packet
574            headers, we switch to partial length encoding. */
575         if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
576           filesize = tmpsize;
577         else
578           filesize = 0;
579
580         /* Because the text_filter modifies the length of the
581          * data, it is not possible to know the used length
582          * without a double read of the file - to avoid that
583          * we simple use partial length packets. */
584         if ( ptmode == 't' )
585           filesize = 0;
586       }
587     else
588       filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
589
590     if (!opt.no_literal) {
591         PACKET pkt;
592
593         pt->timestamp = make_timestamp ();
594         pt->mode = ptmode;
595         pt->len = filesize;
596         pt->new_ctb = !pt->len && !RFC1991;
597         pt->buf = inp;
598         init_packet(&pkt);
599         pkt.pkttype = PKT_PLAINTEXT;
600         pkt.pkt.plaintext = pt;
601         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
602         if( (rc = build_packet (out, &pkt)) )
603             log_error ("build_packet(PLAINTEXT) failed: %s\n",
604                        g10_errstr(rc) );
605         pt->buf = NULL;
606     }
607     else {
608         byte copy_buffer[4096];
609         int  bytes_copied;
610
611         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
612             if ( (rc=iobuf_write(out, copy_buffer, bytes_copied)) ) {
613                 log_error ("copying input to output failed: %s\n",
614                            gpg_strerror (rc));
615                 break;
616             }
617         wipememory(copy_buffer,4096); /* burn buffer */
618     }
619     /* fixme: it seems that we never freed pt/pkt */
620     
621     return rc;
622 }
623
624 /*
625  * Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
626  * hash which will not be changes here.
627  */
628 static int
629 write_signature_packets (SK_LIST sk_list, IOBUF out, gcry_md_hd_t hash,
630                          int sigclass, u32 timestamp, u32 duration,
631                          int status_letter)
632 {
633   SK_LIST sk_rover;
634   
635   /* Loop over the certificates with secret keys. */
636   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
637     {
638       PKT_public_key *pk;
639       PKT_signature *sig;
640       gcry_md_hd_t md;
641       int rc;
642
643       pk = sk_rover->pk;
644
645       /* Build the signature packet.  */
646       sig = xmalloc_clear (sizeof *sig);
647       if (opt.force_v3_sigs || RFC1991)
648         sig->version = 3;
649       else if (duration || opt.sig_policy_url
650                || opt.sig_notations || opt.sig_keyserver_url)
651         sig->version = 4;
652       else
653         sig->version = pk->version;
654
655       keyid_from_pk (pk, sig->keyid);
656       sig->digest_algo = hash_for (pk);
657       sig->pubkey_algo = pk->pubkey_algo;
658       if (timestamp)
659         sig->timestamp = timestamp;
660       else
661         sig->timestamp = make_timestamp();
662       if (duration)
663         sig->expiredate = sig->timestamp + duration;
664       sig->sig_class = sigclass;
665
666       if (gcry_md_copy (&md, hash))
667         BUG ();
668       
669       if (sig->version >= 4)
670         {
671           build_sig_subpkt_from_sig (sig);
672           mk_notation_policy_etc (sig, pk, NULL);
673         }
674       
675       hash_sigversion_to_magic (md, sig);
676       gcry_md_final (md);
677
678       rc = do_sign (pk, sig, md, hash_for (pk));
679       gcry_md_close (md);
680       if (!rc)
681         { 
682           /* Write the packet.  */
683           PACKET pkt;
684           
685           init_packet (&pkt);
686           pkt.pkttype = PKT_SIGNATURE;
687           pkt.pkt.signature = sig;
688           rc = build_packet (out, &pkt);
689           if (!rc && is_status_enabled())
690             print_status_sig_created (pk, sig, status_letter);
691           free_packet (&pkt);
692           if (rc)
693             log_error ("build signature packet failed: %s\n", gpg_strerror (rc));
694         }
695       if (rc)
696         return rc;
697     }
698   
699   return 0;
700 }
701
702
703 /****************
704  * Sign the files whose names are in FILENAME.
705  * If DETACHED has the value true,
706  * make a detached signature.  If FILENAMES->d is NULL read from stdin
707  * and ignore the detached mode.  Sign the file with all secret keys
708  * which can be taken from LOCUSR, if this is NULL, use the default one
709  * If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to encrypt the
710  * signed data for these users.
711  * If OUTFILE is not NULL; this file is used for output and the function
712  * does not ask for overwrite permission; output is then always
713  * uncompressed, non-armored and in binary mode.
714  */
715 int
716 sign_file( strlist_t filenames, int detached, strlist_t locusr,
717            int encryptflag, strlist_t remusr, const char *outfile )
718 {
719     const char *fname;
720     armor_filter_context_t *afx;
721     compress_filter_context_t zfx;
722     md_filter_context_t mfx;
723     text_filter_context_t tfx;
724     progress_filter_context_t *pfx;
725     encrypt_filter_context_t efx;
726     IOBUF inp = NULL, out = NULL;
727     PACKET pkt;
728     int rc = 0;
729     PK_LIST pk_list = NULL;
730     SK_LIST sk_list = NULL;
731     SK_LIST sk_rover = NULL;
732     int multifile = 0;
733     u32 duration=0;
734
735     pfx = new_progress_context ();
736     afx = new_armor_context ();
737     memset( &zfx, 0, sizeof zfx);
738     memset( &mfx, 0, sizeof mfx);
739     memset( &efx, 0, sizeof efx);
740     init_packet( &pkt );
741
742     if( filenames ) {
743         fname = filenames->d;
744         multifile = !!filenames->next;
745     }
746     else
747         fname = NULL;
748
749     if( fname && filenames->next && (!detached || encryptflag) )
750         log_bug("multiple files can only be detached signed");
751
752     if(encryptflag==2
753        && (rc=setup_symkey(&efx.symkey_s2k,&efx.symkey_dek)))
754       goto leave;
755
756     if(!opt.force_v3_sigs && !RFC1991)
757       {
758         if(opt.ask_sig_expire && !opt.batch)
759           duration=ask_expire_interval(1,opt.def_sig_expire);
760         else
761           duration=parse_expire_string(opt.def_sig_expire);
762       }
763
764     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
765         goto leave;
766
767     if(PGP2 && !only_old_style(sk_list))
768       {
769         log_info(_("you can only detach-sign with PGP 2.x style keys "
770                    "while in --pgp2 mode\n"));
771         compliance_failure();
772       }
773
774     if(encryptflag && (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )))
775       goto leave;
776
777     /* prepare iobufs */
778     if( multifile )  /* have list of filenames */
779         inp = NULL; /* we do it later */
780     else {
781       inp = iobuf_open(fname);
782       if (inp && is_secured_file (iobuf_get_fd (inp)))
783         {
784           iobuf_close (inp);
785           inp = NULL;
786           gpg_err_set_errno (EPERM);
787         }
788       if( !inp ) 
789         {
790           rc = gpg_error_from_syserror ();
791           log_error (_("can't open `%s': %s\n"), fname? fname: "[stdin]",
792                      strerror(errno) );
793           goto leave;
794         }
795
796         handle_progress (pfx, inp, fname);
797     }
798
799     if( outfile ) {
800         if (is_secured_filename ( outfile )) {
801             out = NULL;
802             gpg_err_set_errno (EPERM);
803         }
804         else
805             out = iobuf_create( outfile );
806         if( !out )
807           {
808             rc = gpg_error_from_syserror ();
809             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
810             goto leave;
811           }
812         else if( opt.verbose )
813             log_info(_("writing to `%s'\n"), outfile );
814     }
815     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname,
816                                  opt.armor? 1: detached? 2:0, &out )))
817         goto leave;
818
819     /* prepare to calculate the MD over the input */
820     if( opt.textmode && !outfile && !multifile )
821       {
822         memset( &tfx, 0, sizeof tfx);
823         iobuf_push_filter( inp, text_filter, &tfx );
824       }
825
826     if ( gcry_md_open (&mfx.md, 0, 0) )
827       BUG ();
828     if (DBG_HASHING)
829       gcry_md_start_debug (mfx.md, "sign");
830
831     /* If we're encrypting and signing, it is reasonable to pick the
832        hash algorithm to use out of the recepient key prefs.  This is
833        best effort only, as in a DSA2 and smartcard world there are
834        cases where we cannot please everyone with a single hash (DSA2
835        wants >160 and smartcards want =160).  In the future this could
836        be more complex with different hashes for each sk, but the
837        current design requires a single hash for all SKs. */
838     if(pk_list)
839       {
840         if(opt.def_digest_algo)
841           {
842             if(!opt.expert &&
843                select_algo_from_prefs(pk_list,PREFTYPE_HASH,
844                                       opt.def_digest_algo,
845                                       NULL)!=opt.def_digest_algo)
846           log_info(_("WARNING: forcing digest algorithm %s (%d)"
847                      " violates recipient preferences\n"),
848                    gcry_md_algo_name (opt.def_digest_algo),
849                    opt.def_digest_algo );
850           }
851         else
852           {
853             int algo, smartcard=0;
854             union pref_hint hint;
855
856             hint.digest_length = 0;
857
858             /* Of course, if the recipient asks for something
859                unreasonable (like the wrong hash for a DSA key) then
860                don't do it.  Check all sk's - if any are DSA or live
861                on a smartcard, then the hash has restrictions and we
862                may not be able to give the recipient what they want.
863                For DSA, pass a hint for the largest q we have.  Note
864                that this means that a q>160 key will override a q=160
865                key and force the use of truncation for the q=160 key.
866                The alternative would be to ignore the recipient prefs
867                completely and get a different hash for each DSA key in
868                hash_for().  The override behavior here is more or less
869                reasonable as it is under the control of the user which
870                keys they sign with for a given message and the fact
871                that the message with multiple signatures won't be
872                usable on an implementation that doesn't understand
873                DSA2 anyway. */
874
875             for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
876               {
877                 if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_DSA)
878                   {
879                     int temp_hashlen = gcry_mpi_get_nbits
880                       (sk_rover->pk->pkey[1])+7/8;
881
882                     /* Pick a hash that is large enough for our
883                        largest q */
884
885                     if (hint.digest_length<temp_hashlen)
886                       hint.digest_length=temp_hashlen;
887                   }
888                 /* FIXME: need toall gpg-agent */
889                 /* else if (sk_rover->pk->is_protected */
890                 /*          && sk_rover->pk->protect.s2k.mode == 1002) */
891                 /*   smartcard = 1;  */
892               }
893
894             /* Current smartcards only do 160-bit hashes.  If we have
895                to have a >160-bit hash, then we can't use the
896                recipient prefs as we'd need both =160 and >160 at the
897                same time and recipient prefs currently require a
898                single hash for all signatures.  All this may well have
899                to change as the cards add algorithms. */
900
901             if (!smartcard || (smartcard && hint.digest_length==20))
902               if ( (algo=
903                    select_algo_from_prefs(pk_list,PREFTYPE_HASH,-1,&hint)) > 0)
904                 recipient_digest_algo=algo;
905           }
906       }
907
908     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
909       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
910
911     if( !multifile )
912         iobuf_push_filter( inp, md_filter, &mfx );
913
914     if( detached && !encryptflag && !RFC1991 )
915         afx->what = 2;
916
917     if( opt.armor && !outfile  )
918         push_armor_filter (afx, out);
919
920     if( encryptflag ) {
921         efx.pk_list = pk_list;
922         /* fixme: set efx.cfx.datalen if known */
923         iobuf_push_filter( out, encrypt_filter, &efx );
924     }
925
926     if( opt.compress_algo && !outfile && ( !detached || opt.compress_sigs) )
927       {
928         int compr_algo=opt.compress_algo;
929
930         /* If not forced by user */
931         if(compr_algo==-1)
932           {
933             /* If we're not encrypting, then select_algo_from_prefs
934                will fail and we'll end up with the default.  If we are
935                encrypting, select_algo_from_prefs cannot fail since
936                there is an assumed preference for uncompressed data.
937                Still, if it did fail, we'll also end up with the
938                default. */
939  
940             if((compr_algo=
941                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
942               compr_algo=default_compress_algo();
943           }
944         else if(!opt.expert && pk_list
945                 && select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
946                                           compr_algo,NULL)!=compr_algo)
947           log_info(_("WARNING: forcing compression algorithm %s (%d)"
948                      " violates recipient preferences\n"),
949                    compress_algo_to_string(compr_algo),compr_algo);
950
951         /* algo 0 means no compression */
952         if( compr_algo )
953           push_compress_filter(out,&zfx,compr_algo);
954       }
955
956     /* Write the one-pass signature packets if needed */
957     if (!detached && !RFC1991) {
958         rc = write_onepass_sig_packets (sk_list, out,
959                                         opt.textmode && !outfile ? 0x01:0x00);
960         if (rc)
961             goto leave;
962     }
963
964     write_status_begin_signing (mfx.md);
965
966     /* Setup the inner packet. */
967     if( detached ) {
968         if( multifile ) {
969             strlist_t sl;
970
971             if( opt.verbose )
972                 log_info(_("signing:") );
973             /* must walk reverse trough this list */
974             for( sl = strlist_last(filenames); sl;
975                         sl = strlist_prev( filenames, sl ) ) {
976                 inp = iobuf_open(sl->d);
977                 if (inp && is_secured_file (iobuf_get_fd (inp)))
978                   {
979                     iobuf_close (inp);
980                     inp = NULL;
981                     gpg_err_set_errno (EPERM);
982                   }
983                 if( !inp )
984                   {
985                     rc = gpg_error_from_syserror ();
986                     log_error(_("can't open `%s': %s\n"),
987                               sl->d,strerror(errno));
988                     goto leave;
989                   }
990                 handle_progress (pfx, inp, sl->d);
991                 if( opt.verbose )
992                     fprintf(stderr, " `%s'", sl->d );
993                 if(opt.textmode)
994                   {
995                     memset( &tfx, 0, sizeof tfx);
996                     iobuf_push_filter( inp, text_filter, &tfx );
997                   }
998                 iobuf_push_filter( inp, md_filter, &mfx );
999                 while( iobuf_get(inp) != -1 )
1000                     ;
1001                 iobuf_close(inp); inp = NULL;
1002             }
1003             if( opt.verbose )
1004                 putc( '\n', stderr );
1005         }
1006         else {
1007             /* read, so that the filter can calculate the digest */
1008             while( iobuf_get(inp) != -1 )
1009                 ;
1010         }
1011     }
1012     else {
1013         rc = write_plaintext_packet (out, inp, fname,
1014                                      opt.textmode && !outfile ? 't':'b');
1015     }
1016
1017     /* catch errors from above */
1018     if (rc)
1019         goto leave;
1020
1021     /* write the signatures */
1022     rc = write_signature_packets (sk_list, out, mfx.md,
1023                                   opt.textmode && !outfile? 0x01 : 0x00,
1024                                   0, duration, detached ? 'D':'S');
1025     if( rc )
1026         goto leave;
1027
1028
1029   leave:
1030     if( rc )
1031         iobuf_cancel(out);
1032     else {
1033         iobuf_close(out);
1034         if (encryptflag)
1035             write_status( STATUS_END_ENCRYPTION );
1036     }
1037     iobuf_close(inp);
1038     gcry_md_close ( mfx.md );
1039     release_sk_list( sk_list );
1040     release_pk_list( pk_list );
1041     recipient_digest_algo=0;
1042     release_progress_context (pfx);
1043     release_armor_context (afx);
1044     return rc;
1045 }
1046
1047
1048
1049 /****************
1050  * make a clear signature. note that opt.armor is not needed
1051  */
1052 int
1053 clearsign_file( const char *fname, strlist_t locusr, const char *outfile )
1054 {
1055     armor_filter_context_t *afx;
1056     progress_filter_context_t *pfx;
1057     gcry_md_hd_t textmd = NULL;
1058     IOBUF inp = NULL, out = NULL;
1059     PACKET pkt;
1060     int rc = 0;
1061     SK_LIST sk_list = NULL;
1062     SK_LIST sk_rover = NULL;
1063     int old_style = RFC1991;
1064     int only_md5 = 0;
1065     u32 duration=0;
1066
1067     pfx = new_progress_context ();
1068     afx = new_armor_context ();
1069     init_packet( &pkt );
1070
1071     if(!opt.force_v3_sigs && !RFC1991)
1072       {
1073         if(opt.ask_sig_expire && !opt.batch)
1074           duration=ask_expire_interval(1,opt.def_sig_expire);
1075         else
1076           duration=parse_expire_string(opt.def_sig_expire);
1077       }
1078
1079     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
1080         goto leave;
1081
1082     if( !old_style && !duration )
1083         old_style = only_old_style( sk_list );
1084
1085     if(PGP2 && !only_old_style(sk_list))
1086       {
1087         log_info(_("you can only clearsign with PGP 2.x style keys "
1088                    "while in --pgp2 mode\n"));
1089         compliance_failure();
1090       }
1091
1092     /* prepare iobufs */
1093     inp = iobuf_open(fname);
1094     if (inp && is_secured_file (iobuf_get_fd (inp)))
1095       {
1096         iobuf_close (inp);
1097         inp = NULL;
1098         gpg_err_set_errno (EPERM);
1099       }
1100     if( !inp ) {
1101         rc = gpg_error_from_syserror ();
1102         log_error (_("can't open `%s': %s\n"), 
1103                    fname? fname: "[stdin]", strerror(errno) );
1104         goto leave;
1105     }
1106     handle_progress (pfx, inp, fname);
1107
1108     if( outfile ) {
1109         if (is_secured_filename (outfile) ) {
1110             outfile = NULL;
1111             gpg_err_set_errno (EPERM);
1112         }
1113         else 
1114             out = iobuf_create( outfile );
1115         if( !out )
1116           {
1117             rc = gpg_error_from_syserror ();
1118             log_error(_("can't create `%s': %s\n"), outfile, strerror(errno) );
1119             goto leave;
1120           }
1121         else if( opt.verbose )
1122             log_info(_("writing to `%s'\n"), outfile );
1123     }
1124     else if( (rc = open_outfile (GNUPG_INVALID_FD, fname, 1, &out )) )
1125         goto leave;
1126
1127     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
1128
1129     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1130       {
1131         if (hash_for (sk_rover->pk) == DIGEST_ALGO_MD5)
1132           only_md5 = 1;
1133         else 
1134           {
1135             only_md5 = 0;
1136             break;
1137           }
1138       }
1139
1140     if( !(old_style && only_md5) ) {
1141         const char *s;
1142         int any = 0;
1143         byte hashs_seen[256];
1144
1145         memset( hashs_seen, 0, sizeof hashs_seen );
1146         iobuf_writestr(out, "Hash: " );
1147         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
1148             int i = hash_for (sk_rover->pk);
1149
1150             if( !hashs_seen[ i & 0xff ] ) {
1151                 s = gcry_md_algo_name ( i );
1152                 if( s ) {
1153                     hashs_seen[ i & 0xff ] = 1;
1154                     if( any )
1155                         iobuf_put(out, ',' );
1156                     iobuf_writestr(out, s );
1157                     any = 1;
1158                 }
1159             }
1160         }
1161         assert(any);
1162         iobuf_writestr(out, LF );
1163     }
1164
1165     if( opt.not_dash_escaped )
1166       iobuf_writestr( out,
1167                   "NotDashEscaped: You need GnuPG to verify this message" LF );
1168     iobuf_writestr(out, LF );
1169
1170     if ( gcry_md_open (&textmd, 0, 0) )
1171       BUG ();
1172     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1173       gcry_md_enable (textmd, hash_for(sk_rover->pk));
1174
1175     if ( DBG_HASHING )
1176       gcry_md_start_debug ( textmd, "clearsign" );
1177
1178     copy_clearsig_text( out, inp, textmd, !opt.not_dash_escaped,
1179                         opt.escape_from, (old_style && only_md5) );
1180     /* fixme: check for read errors */
1181
1182     /* now write the armor */
1183     afx->what = 2;
1184     push_armor_filter (afx, out);
1185
1186     /* write the signatures */
1187     rc=write_signature_packets (sk_list, out, textmd, 0x01, 0, duration, 'C');
1188     if( rc )
1189         goto leave;
1190
1191   leave:
1192     if( rc )
1193         iobuf_cancel(out);
1194     else
1195         iobuf_close(out);
1196     iobuf_close(inp);
1197     gcry_md_close ( textmd );
1198     release_sk_list( sk_list );
1199     release_progress_context (pfx);
1200     release_armor_context (afx); 
1201     return rc;
1202 }
1203
1204 /*
1205  * Sign and conventionally encrypt the given file.
1206  * FIXME: Far too much code is duplicated - revamp the whole file.
1207  */
1208 int
1209 sign_symencrypt_file (const char *fname, strlist_t locusr)
1210 {
1211     armor_filter_context_t *afx;
1212     progress_filter_context_t *pfx;
1213     compress_filter_context_t zfx;
1214     md_filter_context_t mfx;
1215     text_filter_context_t tfx;
1216     cipher_filter_context_t cfx;
1217     IOBUF inp = NULL, out = NULL;
1218     PACKET pkt;
1219     STRING2KEY *s2k = NULL;
1220     int rc = 0;
1221     SK_LIST sk_list = NULL;
1222     SK_LIST sk_rover = NULL;
1223     int algo;
1224     u32 duration=0;
1225     int canceled;
1226
1227     pfx = new_progress_context ();
1228     afx = new_armor_context ();
1229     memset( &zfx, 0, sizeof zfx);
1230     memset( &mfx, 0, sizeof mfx);
1231     memset( &tfx, 0, sizeof tfx);
1232     memset( &cfx, 0, sizeof cfx);
1233     init_packet( &pkt );
1234
1235     if(!opt.force_v3_sigs && !RFC1991)
1236       {
1237         if(opt.ask_sig_expire && !opt.batch)
1238           duration=ask_expire_interval(1,opt.def_sig_expire);
1239         else
1240           duration=parse_expire_string(opt.def_sig_expire);
1241       }
1242
1243     rc = build_sk_list (locusr, &sk_list, 1, PUBKEY_USAGE_SIG);
1244     if (rc) 
1245         goto leave;
1246
1247     /* prepare iobufs */
1248     inp = iobuf_open(fname);
1249     if (inp && is_secured_file (iobuf_get_fd (inp)))
1250       {
1251         iobuf_close (inp);
1252         inp = NULL;
1253         gpg_err_set_errno (EPERM);
1254       }
1255     if( !inp ) {
1256         rc = gpg_error_from_syserror ();
1257         log_error (_("can't open `%s': %s\n"), 
1258                    fname? fname: "[stdin]", strerror(errno) );
1259         goto leave;
1260     }
1261     handle_progress (pfx, inp, fname);
1262
1263     /* prepare key */
1264     s2k = xmalloc_clear( sizeof *s2k );
1265     s2k->mode = RFC1991? 0:opt.s2k_mode;
1266     s2k->hash_algo = S2K_DIGEST_ALGO;
1267
1268     algo = default_cipher_algo();
1269     if (!opt.quiet || !opt.batch)
1270         log_info (_("%s encryption will be used\n"),
1271                   openpgp_cipher_algo_name (algo) );
1272     cfx.dek = passphrase_to_dek( NULL, 0, algo, s2k, 2, NULL, &canceled);
1273
1274     if (!cfx.dek || !cfx.dek->keylen) {
1275         rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
1276         log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
1277         goto leave;
1278     }
1279
1280     /* We have no way to tell if the recipient can handle messages
1281        with an MDC, so this defaults to no.  Perhaps in a few years,
1282        this can be defaulted to yes.  Note that like regular
1283        encrypting, --force-mdc overrides --disable-mdc. */
1284     if(opt.force_mdc)
1285       cfx.dek->use_mdc=1;
1286
1287     /* now create the outfile */
1288     rc = open_outfile (GNUPG_INVALID_FD, fname, opt.armor? 1:0, &out);
1289     if (rc)
1290         goto leave;
1291
1292     /* prepare to calculate the MD over the input */
1293     if (opt.textmode)
1294         iobuf_push_filter (inp, text_filter, &tfx);
1295     if ( gcry_md_open (&mfx.md, 0, 0) )
1296       BUG ();
1297     if ( DBG_HASHING )
1298       gcry_md_start_debug (mfx.md, "symc-sign");
1299
1300     for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
1301       gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
1302
1303     iobuf_push_filter (inp, md_filter, &mfx);
1304
1305     /* Push armor output filter */
1306     if (opt.armor)
1307         push_armor_filter (afx, out);
1308
1309     /* Write the symmetric key packet */
1310     /*(current filters: armor)*/
1311     if (!RFC1991) {
1312         PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
1313         enc->version = 4;
1314         enc->cipher_algo = cfx.dek->algo;
1315         enc->s2k = *s2k;
1316         pkt.pkttype = PKT_SYMKEY_ENC;
1317         pkt.pkt.symkey_enc = enc;
1318         if( (rc = build_packet( out, &pkt )) )
1319             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
1320         xfree(enc);
1321     }
1322
1323     /* Push the encryption filter */
1324     iobuf_push_filter( out, cipher_filter, &cfx );
1325
1326     /* Push the compress filter */
1327     if (default_compress_algo())
1328       push_compress_filter(out,&zfx,default_compress_algo());
1329
1330     /* Write the one-pass signature packets */
1331     /*(current filters: zip - encrypt - armor)*/
1332     if (!RFC1991) {
1333         rc = write_onepass_sig_packets (sk_list, out,
1334                                         opt.textmode? 0x01:0x00);
1335         if (rc)
1336             goto leave;
1337     }
1338
1339     write_status_begin_signing (mfx.md);
1340
1341     /* Pipe data through all filters; i.e. write the signed stuff */
1342     /*(current filters: zip - encrypt - armor)*/
1343     rc = write_plaintext_packet (out, inp, fname, opt.textmode ? 't':'b');
1344     if (rc)
1345         goto leave;
1346     
1347     /* Write the signatures */
1348     /*(current filters: zip - encrypt - armor)*/
1349     rc = write_signature_packets (sk_list, out, mfx.md,
1350                                   opt.textmode? 0x01 : 0x00,
1351                                   0, duration, 'S');
1352     if( rc )
1353         goto leave;
1354
1355
1356   leave:
1357     if( rc )
1358         iobuf_cancel(out);
1359     else {
1360         iobuf_close(out);
1361         write_status( STATUS_END_ENCRYPTION );
1362     }
1363     iobuf_close(inp);
1364     release_sk_list( sk_list );
1365     gcry_md_close( mfx.md );
1366     xfree(cfx.dek);
1367     xfree(s2k);
1368     release_progress_context (pfx);
1369     release_armor_context (afx);
1370     return rc;
1371 }
1372
1373
1374 /****************
1375  * Create a signature packet for the given public key certificate and
1376  * the user id and return it in ret_sig. User signature class SIGCLASS
1377  * user-id is not used (and may be NULL if sigclass is 0x20) If
1378  * DIGEST_ALGO is 0 the function selects an appropriate one.
1379  * SIGVERSION gives the minimal required signature packet version;
1380  * this is needed so that special properties like local sign are not
1381  * applied (actually: dropped) when a v3 key is used.  TIMESTAMP is
1382  * the timestamp to use for the signature. 0 means "now" */
1383 int
1384 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
1385                     PKT_user_id *uid, PKT_public_key *subpk,
1386                     PKT_public_key *pksk,
1387                     int sigclass, int digest_algo,
1388                     int sigversion, u32 timestamp, u32 duration,
1389                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
1390                    )
1391 {
1392     PKT_signature *sig;
1393     int rc=0;
1394     gcry_md_hd_t md;
1395
1396     assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
1397             || sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
1398             || sigclass == 0x30 || sigclass == 0x28 );
1399
1400     if (opt.force_v4_certs)
1401         sigversion = 4;
1402
1403     if (sigversion < pksk->version)
1404         sigversion = pksk->version;
1405
1406     /* If you are making a signature on a v4 key using your v3 key, it
1407        doesn't make sense to generate a v3 sig.  After all, no v3-only
1408        PGP implementation could understand the v4 key in the first
1409        place.  Note that this implies that a signature on an attribute
1410        uid is usually going to be v4 as well, since they are not
1411        generally found on v3 keys. */
1412     if (sigversion < pk->version)
1413         sigversion = pk->version;
1414
1415     if( !digest_algo )
1416       {
1417         /* Basically, this means use SHA1 always unless it's a v3 RSA
1418            key making a v3 cert (use MD5), or the user specified
1419            something (use whatever they said), or it's DSA (use the
1420            best match).  They still can't pick an inappropriate hash
1421            for DSA or the signature will fail.  Note that this still
1422            allows the caller of make_keysig_packet to override the
1423            user setting if it must. */
1424
1425         if(opt.cert_digest_algo)
1426           digest_algo=opt.cert_digest_algo;
1427         else if(pksk->pubkey_algo==PUBKEY_ALGO_RSA
1428                 && pk->version<4 && sigversion<4)
1429           digest_algo = DIGEST_ALGO_MD5;
1430         else if(pksk->pubkey_algo==PUBKEY_ALGO_DSA)
1431           digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
1432         else
1433           digest_algo = DIGEST_ALGO_SHA1;
1434       }
1435
1436     if ( gcry_md_open (&md, digest_algo, 0 ) )
1437       BUG ();
1438
1439     /* Hash the public key certificate. */
1440     hash_public_key( md, pk );
1441
1442     if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
1443       {
1444         /* hash the subkey binding/backsig/revocation */
1445         hash_public_key( md, subpk );
1446       }
1447     else if( sigclass != 0x1F && sigclass != 0x20 )
1448       {
1449         /* hash the user id */
1450         hash_uid (md, sigversion, uid);
1451       }
1452     /* and make the signature packet */
1453     sig = xmalloc_clear( sizeof *sig );
1454     sig->version = sigversion;
1455     sig->flags.exportable=1;
1456     sig->flags.revocable=1;
1457     keyid_from_pk (pksk, sig->keyid);
1458     sig->pubkey_algo = pksk->pubkey_algo;
1459     sig->digest_algo = digest_algo;
1460     if(timestamp)
1461       sig->timestamp=timestamp;
1462     else
1463       sig->timestamp=make_timestamp();
1464     if(duration)
1465       sig->expiredate=sig->timestamp+duration;
1466     sig->sig_class = sigclass;
1467     if( sig->version >= 4 )
1468       {
1469         build_sig_subpkt_from_sig( sig );
1470         mk_notation_policy_etc (sig, pk, pksk);
1471       }
1472
1473     /* Crucial that the call to mksubpkt comes LAST before the calls
1474        to finalize the sig as that makes it possible for the mksubpkt
1475        function to get a reliable pointer to the subpacket area. */
1476     if( sig->version >= 4 && mksubpkt )
1477         rc = (*mksubpkt)( sig, opaque );
1478
1479     if( !rc ) {
1480         hash_sigversion_to_magic (md, sig);
1481         gcry_md_final (md);
1482
1483         rc = complete_sig (sig, pksk, md);
1484     }
1485
1486     gcry_md_close (md);
1487     if( rc )
1488         free_seckey_enc( sig );
1489     else
1490         *ret_sig = sig;
1491     return rc;
1492 }
1493
1494
1495
1496 /****************
1497  * Create a new signature packet based on an existing one.
1498  * Only user ID signatures are supported for now.
1499  * TODO: Merge this with make_keysig_packet.
1500  */
1501 int
1502 update_keysig_packet( PKT_signature **ret_sig,
1503                       PKT_signature *orig_sig,
1504                       PKT_public_key *pk,
1505                       PKT_user_id *uid, 
1506                       PKT_public_key *subpk,
1507                       PKT_public_key *pksk,
1508                       int (*mksubpkt)(PKT_signature *, void *),
1509                       void *opaque )
1510 {
1511     PKT_signature *sig;
1512     int rc=0;
1513     gcry_md_hd_t md;
1514
1515     if ((!orig_sig || !pk || !pksk)
1516         || (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
1517         || (orig_sig->sig_class == 0x18 && !subpk))
1518       return G10ERR_GENERAL;
1519
1520     if ( gcry_md_open (&md, orig_sig->digest_algo, 0 ) )
1521       BUG ();
1522
1523     /* Hash the public key certificate and the user id. */
1524     hash_public_key( md, pk );
1525
1526     if( orig_sig->sig_class == 0x18 )
1527       hash_public_key( md, subpk );
1528     else
1529       hash_uid (md, orig_sig->version, uid);
1530
1531     /* create a new signature packet */
1532     sig = copy_signature (NULL, orig_sig);
1533  
1534     /* We need to create a new timestamp so that new sig expiration
1535        calculations are done correctly... */
1536     sig->timestamp=make_timestamp();
1537
1538     /* ... but we won't make a timestamp earlier than the existing
1539        one. */
1540     while(sig->timestamp<=orig_sig->timestamp)
1541       {
1542         gnupg_sleep (1);
1543         sig->timestamp=make_timestamp();
1544       }
1545
1546     /* Note that already expired sigs will remain expired (with a
1547        duration of 1) since build-packet.c:build_sig_subpkt_from_sig
1548        detects this case. */
1549
1550     if( sig->version >= 4 )
1551       {
1552         /* Put the updated timestamp into the sig.  Note that this
1553            will automagically lower any sig expiration dates to
1554            correctly correspond to the differences in the timestamps
1555            (i.e. the duration will shrink). */
1556         build_sig_subpkt_from_sig( sig );
1557
1558         if (mksubpkt)
1559           rc = (*mksubpkt)(sig, opaque);
1560       }
1561
1562     if (!rc) {
1563         hash_sigversion_to_magic (md, sig);
1564         gcry_md_final (md);
1565
1566         rc = complete_sig (sig, pksk, md);
1567     }
1568
1569     gcry_md_close (md);
1570     if( rc )
1571         free_seckey_enc (sig);
1572     else
1573         *ret_sig = sig;
1574     return rc;
1575 }