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