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