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