bb3f2432ad8706093e2243b9e369355715d18c05
[gnupg.git] / g10 / encrypt.c
1 /* encrypt.c - Main encryption driver
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2009 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "gpg.h"
29 #include "options.h"
30 #include "packet.h"
31 #include "status.h"
32 #include "iobuf.h"
33 #include "keydb.h"
34 #include "util.h"
35 #include "main.h"
36 #include "filter.h"
37 #include "trustdb.h"
38 #include "i18n.h"
39 #include "status.h"
40 #include "pkglue.h"
41
42
43 static int encrypt_simple( const char *filename, int mode, int use_seskey );
44 static int write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, iobuf_t out );
45
46 /****************
47  * Encrypt FILENAME with only the symmetric cipher.  Take input from
48  * stdin if FILENAME is NULL.
49  */
50 int
51 encrypt_symmetric (const char *filename)
52 {
53   return encrypt_simple( filename, 1, 0 );
54 }
55
56
57 /****************
58  * Encrypt FILENAME as a literal data packet only. Take input from
59  * stdin if FILENAME is NULL.
60  */
61 int
62 encrypt_store (const char *filename)
63 {
64   return encrypt_simple( filename, 0, 0 );
65 }
66
67
68 static void
69 encrypt_seskey (DEK *dek, DEK **seskey, byte *enckey)
70 {
71   gcry_cipher_hd_t hd;
72   byte buf[33];
73
74   assert ( dek->keylen <= 32 );
75   if (!*seskey)
76     {
77       *seskey=xmalloc_clear(sizeof(DEK));
78       (*seskey)->keylen=dek->keylen;
79       (*seskey)->algo=dek->algo;
80       make_session_key(*seskey);
81       /*log_hexdump( "thekey", c->key, c->keylen );*/
82     }
83
84   /* The encrypted session key is prefixed with a one-octet algorithm id.  */
85   buf[0] = (*seskey)->algo;
86   memcpy( buf + 1, (*seskey)->key, (*seskey)->keylen );
87     
88   /* We only pass already checked values to the following fucntion,
89      thus we consider any failure as fatal.  */
90   if (openpgp_cipher_open (&hd, dek->algo, GCRY_CIPHER_MODE_CFB, 1))
91     BUG ();
92   if (gcry_cipher_setkey (hd, dek->key, dek->keylen))
93     BUG ();
94   gcry_cipher_setiv (hd, NULL, 0);
95   gcry_cipher_encrypt (hd, buf, (*seskey)->keylen + 1, NULL, 0);
96   gcry_cipher_close (hd);
97
98   memcpy( enckey, buf, (*seskey)->keylen + 1 );
99   wipememory( buf, sizeof buf ); /* burn key */
100 }
101
102
103 /* We try very hard to use a MDC */
104 static int
105 use_mdc(PK_LIST pk_list,int algo)
106 {
107   /* RFC-1991 and 2440 don't have MDC */
108   if(RFC1991 || RFC2440)
109     return 0;
110
111   /* --force-mdc overrides --disable-mdc */
112   if(opt.force_mdc)
113     return 1;
114
115   if(opt.disable_mdc)
116     return 0;
117
118   /* Do the keys really support MDC? */
119
120   if(select_mdc_from_pklist(pk_list))
121     return 1;
122   
123   /* The keys don't support MDC, so now we do a bit of a hack - if any
124      of the AESes or TWOFISH are in the prefs, we assume that the user
125      can handle a MDC.  This is valid for PGP 7, which can handle MDCs
126      though it will not generate them.  2440bis allows this, by the
127      way. */
128
129   if(select_algo_from_prefs(pk_list,PREFTYPE_SYM,
130                             CIPHER_ALGO_AES,NULL)==CIPHER_ALGO_AES)
131     return 1;
132
133   if(select_algo_from_prefs(pk_list,PREFTYPE_SYM,
134                             CIPHER_ALGO_AES192,NULL)==CIPHER_ALGO_AES192)
135     return 1;
136
137   if(select_algo_from_prefs(pk_list,PREFTYPE_SYM,
138                             CIPHER_ALGO_AES256,NULL)==CIPHER_ALGO_AES256)
139     return 1;
140
141   if(select_algo_from_prefs(pk_list,PREFTYPE_SYM,
142                             CIPHER_ALGO_TWOFISH,NULL)==CIPHER_ALGO_TWOFISH)
143     return 1;
144
145   /* Last try.  Use MDC for the modern ciphers. */
146
147   if (openpgp_cipher_get_algo_blklen (algo) != 8)
148     return 1;
149
150   if (opt.verbose)
151     warn_missing_mdc_from_pklist (pk_list);
152
153   return 0; /* No MDC */
154 }
155
156
157 /* We don't want to use use_seskey yet because older gnupg versions
158    can't handle it, and there isn't really any point unless we're
159    making a message that can be decrypted by a public key or
160    passphrase. */
161 static int
162 encrypt_simple (const char *filename, int mode, int use_seskey)
163 {
164   iobuf_t inp, out;
165   PACKET pkt;
166   PKT_plaintext *pt = NULL;
167   STRING2KEY *s2k = NULL;
168   byte enckey[33];
169   int rc = 0;
170   int seskeylen = 0;
171   u32 filesize;
172   cipher_filter_context_t cfx;
173   armor_filter_context_t  *afx = NULL;
174   compress_filter_context_t zfx;
175   text_filter_context_t tfx;
176   progress_filter_context_t *pfx;
177   int do_compress = !RFC1991 && default_compress_algo();
178
179   pfx = new_progress_context ();
180   memset( &cfx, 0, sizeof cfx);
181   memset( &zfx, 0, sizeof zfx);
182   memset( &tfx, 0, sizeof tfx);
183   init_packet(&pkt);
184     
185   /* Prepare iobufs. */
186   inp = iobuf_open(filename);
187   if (inp)
188     iobuf_ioctl (inp,3,1,NULL); /* disable fd caching */
189   if (inp && is_secured_file (iobuf_get_fd (inp)))
190     {
191       iobuf_close (inp);
192       inp = NULL;
193       errno = EPERM;
194     }
195   if (!inp)
196     {
197       rc = gpg_error_from_syserror ();
198       log_error(_("can't open `%s': %s\n"), filename? filename: "[stdin]",
199                 strerror(errno) );
200       release_progress_context (pfx);
201       return rc;
202     }
203   
204   handle_progress (pfx, inp, filename);
205   
206   if (opt.textmode)
207     iobuf_push_filter( inp, text_filter, &tfx );
208   
209   /* Due the the fact that we use don't use an IV to encrypt the
210      session key we can't use the new mode with RFC1991 because it has
211      no S2K salt.  RFC1991 always uses simple S2K. */
212   if ( RFC1991 && use_seskey )
213     use_seskey = 0;
214     
215   cfx.dek = NULL;
216   if ( mode ) 
217     {
218       int canceled;
219       
220       s2k = xmalloc_clear( sizeof *s2k );
221       s2k->mode = RFC1991? 0:opt.s2k_mode;
222       s2k->hash_algo = S2K_DIGEST_ALGO;
223       cfx.dek = passphrase_to_dek (NULL, 0,
224                                    default_cipher_algo(), s2k, 4,
225                                    NULL, &canceled);
226       if ( !cfx.dek || !cfx.dek->keylen )
227         {
228           rc = gpg_error (canceled? GPG_ERR_CANCELED:GPG_ERR_INV_PASSPHRASE);
229           xfree (cfx.dek);
230           xfree (s2k);
231           iobuf_close (inp);
232           log_error (_("error creating passphrase: %s\n"), gpg_strerror (rc));
233           release_progress_context (pfx);
234           return rc;
235         }
236       if (use_seskey && s2k->mode != 1 && s2k->mode != 3) 
237         {
238           use_seskey = 0;
239           log_info (_("can't use a symmetric ESK packet "
240                       "due to the S2K mode\n"));
241         }
242       
243       if ( use_seskey )
244         {
245           DEK *dek = NULL;
246         
247           seskeylen = openpgp_cipher_get_algo_keylen (default_cipher_algo ());
248           encrypt_seskey( cfx.dek, &dek, enckey );
249           xfree( cfx.dek ); cfx.dek = dek;
250         }
251       
252       if (opt.verbose)
253         log_info(_("using cipher %s\n"),
254                  openpgp_cipher_algo_name (cfx.dek->algo));
255       
256       cfx.dek->use_mdc=use_mdc(NULL,cfx.dek->algo);
257     }
258   
259   if (do_compress && cfx.dek && cfx.dek->use_mdc
260       && is_file_compressed(filename, &rc))
261     {
262       if (opt.verbose)
263         log_info(_("`%s' already compressed\n"), filename);
264       do_compress = 0;        
265     }
266   
267   if ( rc || (rc = open_outfile (GNUPG_INVALID_FD, filename,
268                                  opt.armor? 1:0, &out )))
269     {
270       iobuf_cancel (inp);
271       xfree (cfx.dek);
272       xfree (s2k);
273       release_progress_context (pfx);
274       return rc;
275     }
276   
277   if ( opt.armor )
278     {
279       afx = new_armor_context ();
280       push_armor_filter (afx, out);
281     }
282
283   if ( s2k && !RFC1991 )
284     {
285       PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc + seskeylen + 1 );
286       enc->version = 4;
287       enc->cipher_algo = cfx.dek->algo;
288       enc->s2k = *s2k;
289       if ( use_seskey && seskeylen )
290         {
291           enc->seskeylen = seskeylen + 1; /* algo id */
292           memcpy (enc->seskey, enckey, seskeylen + 1 );
293         }
294       pkt.pkttype = PKT_SYMKEY_ENC;
295       pkt.pkt.symkey_enc = enc;
296       if ((rc = build_packet( out, &pkt )))
297         log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
298       xfree (enc);
299     }
300   
301   if (!opt.no_literal)
302     pt = setup_plaintext_name (filename, inp);
303
304   /* Note that PGP 5 has problems decrypting symmetrically encrypted
305      data if the file length is in the inner packet. It works when
306      only partial length headers are use.  In the past, we always used
307      partial body length here, but since PGP 2, PGP 6, and PGP 7 need
308      the file length, and nobody should be using PGP 5 nowadays
309      anyway, this is now set to the file length.  Note also that this
310      only applies to the RFC-1991 style symmetric messages, and not
311      the RFC-2440 style.  PGP 6 and 7 work with either partial length
312      or fixed length with the new style messages. */
313
314   if ( !iobuf_is_pipe_filename (filename) && *filename && !opt.textmode )
315     {
316       off_t tmpsize;
317       int overflow;
318
319       if ( !(tmpsize = iobuf_get_filelength(inp, &overflow))
320            && !overflow && opt.verbose)
321         log_info(_("WARNING: `%s' is an empty file\n"), filename );
322       /* We can't encode the length of very large files because
323          OpenPGP uses only 32 bit for file sizes.  So if the the
324          size of a file is larger than 2^32 minus some bytes for
325          packet headers, we switch to partial length encoding. */
326       if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
327         filesize = tmpsize;
328       else
329         filesize = 0;
330     }
331   else
332     filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
333
334   if (!opt.no_literal)
335     {
336       pt->timestamp = make_timestamp();
337       pt->mode = opt.textmode? 't' : 'b';
338       pt->len = filesize;
339       pt->new_ctb = !pt->len && !RFC1991;
340       pt->buf = inp;
341       pkt.pkttype = PKT_PLAINTEXT;
342       pkt.pkt.plaintext = pt;
343       cfx.datalen = filesize && !do_compress ? calc_packet_length( &pkt ) : 0;
344     }
345   else
346     {
347       cfx.datalen = filesize && !do_compress ? filesize : 0;
348       pkt.pkttype = 0;
349       pkt.pkt.generic = NULL;
350     }
351   
352   /* Register the cipher filter. */
353   if (mode)
354     iobuf_push_filter ( out, cipher_filter, &cfx );
355
356   /* Register the compress filter. */
357   if ( do_compress )
358     {
359       if (cfx.dek && cfx.dek->use_mdc)
360         zfx.new_ctb = 1;
361       push_compress_filter (out, &zfx, default_compress_algo());
362     }
363   
364   /* Do the work. */
365   if (!opt.no_literal)
366     {
367       if ( (rc = build_packet( out, &pkt )) )
368         log_error("build_packet failed: %s\n", g10_errstr(rc) );
369     }
370   else 
371     {
372       /* User requested not to create a literal packet, so we copy the
373          plain data.  */
374     byte copy_buffer[4096];
375     int  bytes_copied;
376     while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
377       if ( (rc=iobuf_write(out, copy_buffer, bytes_copied)) ) {
378         log_error ("copying input to output failed: %s\n",
379                    gpg_strerror (rc) );
380         break;
381       }
382     wipememory (copy_buffer, 4096); /* burn buffer */
383     }
384   
385   /* Finish the stuff.  */
386   iobuf_close (inp);
387   if (rc)
388     iobuf_cancel(out);
389   else 
390     {
391       iobuf_close (out); /* fixme: check returncode */
392       if (mode)
393         write_status ( STATUS_END_ENCRYPTION );
394     }
395   if (pt)
396     pt->buf = NULL;
397   free_packet (&pkt);
398   xfree (cfx.dek);
399   xfree (s2k);
400   release_armor_context (afx);
401   release_progress_context (pfx);
402   return rc;
403 }
404
405
406 int
407 setup_symkey (STRING2KEY **symkey_s2k,DEK **symkey_dek)
408 {
409   int canceled;
410
411   *symkey_s2k=xmalloc_clear(sizeof(STRING2KEY));
412   (*symkey_s2k)->mode = opt.s2k_mode;
413   (*symkey_s2k)->hash_algo = S2K_DIGEST_ALGO;
414
415   *symkey_dek=passphrase_to_dek(NULL,0,opt.s2k_cipher_algo,
416                                 *symkey_s2k, 4, NULL, &canceled);
417   if(!*symkey_dek || !(*symkey_dek)->keylen)
418     {
419       xfree(*symkey_dek);
420       xfree(*symkey_s2k);
421       return gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
422     }
423
424   return 0;
425 }
426
427
428 static int
429 write_symkey_enc (STRING2KEY *symkey_s2k, DEK *symkey_dek, DEK *dek, 
430                   iobuf_t out)
431 {
432   int rc, seskeylen = openpgp_cipher_get_algo_keylen (dek->algo);
433
434   PKT_symkey_enc *enc;
435   byte enckey[33];
436   PACKET pkt;
437
438   enc=xmalloc_clear(sizeof(PKT_symkey_enc)+seskeylen+1);
439   encrypt_seskey(symkey_dek,&dek,enckey);
440
441   enc->version = 4;
442   enc->cipher_algo = opt.s2k_cipher_algo;
443   enc->s2k = *symkey_s2k;
444   enc->seskeylen = seskeylen + 1; /* algo id */
445   memcpy( enc->seskey, enckey, seskeylen + 1 );
446
447   pkt.pkttype = PKT_SYMKEY_ENC;
448   pkt.pkt.symkey_enc = enc;
449
450   if ((rc=build_packet(out,&pkt)))
451     log_error("build symkey_enc packet failed: %s\n",g10_errstr(rc));
452
453   xfree(enc);
454   return rc;
455 }
456
457
458 /*
459  * Encrypt the file with the given userids (or ask if none is
460  * supplied).  Either FILENAME or FILEFD must be given, but not both.
461  * The caller may provide a checked list of public keys in
462  * PROVIDED_PKS; if not the function builds a list of keys on its own.
463  */
464 int
465 encrypt_crypt (gnupg_fd_t filefd, const char *filename,
466                strlist_t remusr, int use_symkey, pk_list_t provided_keys,
467                gnupg_fd_t outputfd)
468 {
469   iobuf_t inp = NULL;
470   iobuf_t out = NULL;
471   PACKET pkt;
472   PKT_plaintext *pt = NULL;
473   DEK *symkey_dek = NULL;
474   STRING2KEY *symkey_s2k = NULL;
475   int rc = 0, rc2 = 0;
476   u32 filesize;
477   cipher_filter_context_t cfx;
478   armor_filter_context_t *afx = NULL;
479   compress_filter_context_t zfx;
480   text_filter_context_t tfx;
481   progress_filter_context_t *pfx;
482   PK_LIST pk_list, work_list;
483   int do_compress;
484
485   if (filefd != GNUPG_INVALID_FD && filename)
486     return gpg_error (GPG_ERR_INV_ARG);
487
488   do_compress = opt.compress_algo && !RFC1991;
489
490   pfx = new_progress_context ();
491   memset( &cfx, 0, sizeof cfx);
492   memset( &zfx, 0, sizeof zfx);
493   memset( &tfx, 0, sizeof tfx);
494   init_packet(&pkt);
495
496   if (use_symkey 
497       && (rc=setup_symkey(&symkey_s2k,&symkey_dek)))
498     {
499       release_progress_context (pfx);
500       return rc;
501     }
502
503   if (provided_keys)
504     pk_list = provided_keys;
505   else
506     {
507       if ((rc = build_pk_list (remusr, &pk_list, PUBKEY_USAGE_ENC)))
508         {
509           release_progress_context (pfx);
510           return rc;
511         }
512     }
513   
514   if(PGP2)
515     {
516       for (work_list=pk_list; work_list; work_list=work_list->next)
517         if (!(is_RSA (work_list->pk->pubkey_algo)
518               && nbits_from_pk (work_list->pk) <= 2048))
519           {
520             log_info(_("you can only encrypt to RSA keys of 2048 bits or "
521                        "less in --pgp2 mode\n"));
522             compliance_failure();
523             break;
524           }
525     }
526
527   /* Prepare iobufs. */
528   inp = iobuf_open_fd_or_name (filefd, filename, "rb");
529   if (inp)
530     iobuf_ioctl (inp, 3, 1, NULL); /* Disable fd caching. */
531   if (inp && is_secured_file (iobuf_get_fd (inp)))
532     {
533       iobuf_close (inp);
534       inp = NULL;
535       errno = EPERM;
536     }
537   if (!inp)
538     {
539       char xname[64];
540
541       rc = gpg_error_from_syserror ();
542       if (filefd != GNUPG_INVALID_FD)
543         snprintf (xname, sizeof xname, "[fd %d]", filefd);
544       else if (!filename)
545         strcpy (xname, "[stdin]");
546       else
547         *xname = 0;
548       log_error (_("can't open `%s': %s\n"),
549                  *xname? xname : filename, gpg_strerror (rc) );
550       goto leave;
551     }
552
553   if (opt.verbose)
554     log_info (_("reading from `%s'\n"), iobuf_get_fname_nonnull (inp));
555
556   handle_progress (pfx, inp, filename);
557
558   if (opt.textmode)
559     iobuf_push_filter (inp, text_filter, &tfx);
560
561   rc = open_outfile (outputfd, filename, opt.armor? 1:0, &out);
562   if (rc)
563     goto leave;
564   
565   if (opt.armor)
566     {
567       afx = new_armor_context ();
568       push_armor_filter (afx, out);
569     }
570   
571   /* Create a session key. */
572   cfx.dek = xmalloc_secure_clear (sizeof *cfx.dek);
573   if (!opt.def_cipher_algo)
574     { 
575       /* Try to get it from the prefs.  */
576       cfx.dek->algo = select_algo_from_prefs (pk_list, PREFTYPE_SYM, -1, NULL);
577       /* The only way select_algo_from_prefs can fail here is when
578          mixing v3 and v4 keys, as v4 keys have an implicit preference
579          entry for 3DES, and the pk_list cannot be empty.  In this
580          case, use 3DES anyway as it's the safest choice - perhaps the
581          v3 key is being used in an OpenPGP implementation and we know
582          that the implementation behind any v4 key can handle 3DES. */
583       if (cfx.dek->algo == -1)
584         {
585           cfx.dek->algo = CIPHER_ALGO_3DES;
586           
587           if (PGP2)
588             {
589               log_info(_("unable to use the IDEA cipher for all of the keys "
590                          "you are encrypting to.\n"));
591               compliance_failure();
592             }
593         }
594
595       /* In case 3DES has been selected, print a warning if any key
596          does not have a preference for AES.  This should help to
597          indentify why encrypting to several recipients falls back to
598          3DES. */
599       if (opt.verbose && cfx.dek->algo == CIPHER_ALGO_3DES)
600         warn_missing_aes_from_pklist (pk_list);
601     }
602   else
603     {
604       if (!opt.expert
605           && (select_algo_from_prefs (pk_list, PREFTYPE_SYM,
606                                       opt.def_cipher_algo, NULL)
607               != opt.def_cipher_algo))
608         {
609           log_info(_("WARNING: forcing symmetric cipher %s (%d)"
610                      " violates recipient preferences\n"),
611                    openpgp_cipher_algo_name (opt.def_cipher_algo),
612                    opt.def_cipher_algo);
613         }
614       
615       cfx.dek->algo = opt.def_cipher_algo;
616     }
617   
618   cfx.dek->use_mdc = use_mdc (pk_list,cfx.dek->algo);
619   
620   /* Only do the is-file-already-compressed check if we are using a
621      MDC.  This forces compressed files to be re-compressed if we do
622      not have a MDC to give some protection against chosen ciphertext
623      attacks. */
624
625   if (do_compress && cfx.dek->use_mdc && is_file_compressed(filename, &rc2))
626     {
627       if (opt.verbose)
628         log_info(_("`%s' already compressed\n"), filename);
629       do_compress = 0;        
630     }
631   if (rc2)
632     {
633       rc = rc2;
634       goto leave;
635     }
636
637   make_session_key (cfx.dek);
638   if (DBG_CIPHER)
639     log_printhex ("DEK is: ", cfx.dek->key, cfx.dek->keylen );
640   
641   rc = write_pubkey_enc_from_list (pk_list, cfx.dek, out);
642   if (rc)
643     goto leave;
644
645   /* We put the passphrase (if any) after any public keys as this
646      seems to be the most useful on the recipient side - there is no
647      point in prompting a user for a passphrase if they have the
648      secret key needed to decrypt.  */
649   if(use_symkey && (rc = write_symkey_enc(symkey_s2k,symkey_dek,cfx.dek,out)))
650     goto leave;
651   
652   if (!opt.no_literal)
653     pt = setup_plaintext_name (filename, inp);
654   
655   if (filefd != GNUPG_INVALID_FD 
656       && !iobuf_is_pipe_filename (filename) && *filename && !opt.textmode )
657     {
658       off_t tmpsize;
659       int overflow;
660       
661       if ( !(tmpsize = iobuf_get_filelength(inp, &overflow))
662            && !overflow && opt.verbose)
663         log_info(_("WARNING: `%s' is an empty file\n"), filename );
664       /* We can't encode the length of very large files because
665          OpenPGP uses only 32 bit for file sizes.  So if the the size
666          of a file is larger than 2^32 minus some bytes for packet
667          headers, we switch to partial length encoding. */
668       if (tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
669         filesize = tmpsize;
670       else
671         filesize = 0;
672     }
673   else
674     filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
675
676   if (!opt.no_literal) 
677     {
678       pt->timestamp = make_timestamp();
679       pt->mode = opt.textmode ? 't' : 'b';
680       pt->len = filesize;
681       pt->new_ctb = !pt->len && !RFC1991;
682       pt->buf = inp;
683       pkt.pkttype = PKT_PLAINTEXT;
684       pkt.pkt.plaintext = pt;
685       cfx.datalen = filesize && !do_compress? calc_packet_length( &pkt ) : 0;
686     }
687   else
688     cfx.datalen = filesize && !do_compress ? filesize : 0;
689
690   /* Register the cipher filter. */
691   iobuf_push_filter (out, cipher_filter, &cfx);
692
693   /* Register the compress filter. */
694   if (do_compress)
695     {
696       int compr_algo = opt.compress_algo;
697       
698       if (compr_algo == -1)
699         {
700           compr_algo = select_algo_from_prefs (pk_list, PREFTYPE_ZIP, -1, NULL);
701           if (compr_algo == -1)
702             compr_algo = DEFAULT_COMPRESS_ALGO;
703           /* Theoretically impossible to get here since uncompressed
704              is implicit.  */
705         }
706       else if (!opt.expert 
707                && select_algo_from_prefs(pk_list, PREFTYPE_ZIP,
708                                          compr_algo, NULL) != compr_algo)
709         {
710           log_info (_("WARNING: forcing compression algorithm %s (%d)"
711                       " violates recipient preferences\n"),
712                     compress_algo_to_string(compr_algo), compr_algo);
713         }
714       
715       /* Algo 0 means no compression. */
716       if (compr_algo)
717         {
718           if (cfx.dek && cfx.dek->use_mdc)
719             zfx.new_ctb = 1;
720           push_compress_filter (out,&zfx,compr_algo);
721         }
722     }
723   
724   /* Do the work. */
725   if (!opt.no_literal)
726     {
727       if ((rc = build_packet( out, &pkt )))
728         log_error ("build_packet failed: %s\n", g10_errstr(rc));
729     }
730   else
731     {
732       /* User requested not to create a literal packet, so we copy the
733          plain data. */
734       byte copy_buffer[4096];
735       int  bytes_copied;
736       while ((bytes_copied = iobuf_read (inp, copy_buffer, 4096)) != -1)
737         {
738           rc = iobuf_write (out, copy_buffer, bytes_copied);
739           if (rc)
740             {
741               log_error ("copying input to output failed: %s\n",
742                          gpg_strerror (rc));
743               break;
744             }
745         }
746       wipememory (copy_buffer, 4096); /* Burn the buffer. */
747     }
748
749   /* Finish the stuff. */
750  leave:
751   iobuf_close (inp);
752   if (rc)
753     iobuf_cancel (out);
754   else 
755     {
756       iobuf_close (out); /* fixme: check returncode */
757       write_status (STATUS_END_ENCRYPTION);
758     }
759   if (pt)
760     pt->buf = NULL;
761   free_packet (&pkt);
762   xfree (cfx.dek);
763   xfree (symkey_dek);
764   xfree (symkey_s2k);
765   if (!provided_keys)
766     release_pk_list (pk_list);
767   release_armor_context (afx);
768   release_progress_context (pfx);
769   return rc;
770 }
771
772
773 /*
774  * Filter to do a complete public key encryption.
775  */
776 int
777 encrypt_filter (void *opaque, int control,
778                 iobuf_t a, byte *buf, size_t *ret_len)
779 {
780   size_t size = *ret_len;
781   encrypt_filter_context_t *efx = opaque;
782   int rc = 0;
783   
784   if (control == IOBUFCTRL_UNDERFLOW) /* decrypt */
785     {
786       BUG(); /* not used */
787     }
788   else if ( control == IOBUFCTRL_FLUSH ) /* encrypt */
789     {
790       if ( !efx->header_okay )
791         {
792           efx->cfx.dek = xmalloc_secure_clear ( sizeof *efx->cfx.dek );
793           if ( !opt.def_cipher_algo  ) 
794             {
795               /* Try to get it from the prefs. */
796               efx->cfx.dek->algo =
797                 select_algo_from_prefs (efx->pk_list, PREFTYPE_SYM, -1, NULL);
798               if (efx->cfx.dek->algo == -1 ) 
799                 {
800                   /* Because 3DES is implicitly in the prefs, this can
801                      only happen if we do not have any public keys in
802                      the list.  */
803                   efx->cfx.dek->algo = DEFAULT_CIPHER_ALGO;
804                 }
805               
806               /* In case 3DES has been selected, print a warning if
807                  any key does not have a preference for AES.  This
808                  should help to indentify why encrypting to several
809                  recipients falls back to 3DES. */
810               if (opt.verbose
811                   && efx->cfx.dek->algo == CIPHER_ALGO_3DES)
812                 warn_missing_aes_from_pklist (efx->pk_list);
813             }
814           else 
815             {
816               if (!opt.expert
817                   && select_algo_from_prefs (efx->pk_list,PREFTYPE_SYM,
818                                              opt.def_cipher_algo,
819                                              NULL) != opt.def_cipher_algo)
820                 log_info(_("forcing symmetric cipher %s (%d) "
821                            "violates recipient preferences\n"),
822                          openpgp_cipher_algo_name (opt.def_cipher_algo),
823                          opt.def_cipher_algo);
824               
825               efx->cfx.dek->algo = opt.def_cipher_algo;
826             }
827           
828           efx->cfx.dek->use_mdc = use_mdc (efx->pk_list,efx->cfx.dek->algo);
829           
830           make_session_key ( efx->cfx.dek );
831           if (DBG_CIPHER)
832             log_printhex ("DEK is: ", efx->cfx.dek->key, efx->cfx.dek->keylen);
833
834           rc = write_pubkey_enc_from_list (efx->pk_list, efx->cfx.dek, a);
835           if (rc)
836             return rc;
837
838             if(efx->symkey_s2k && efx->symkey_dek)
839               {
840                 rc=write_symkey_enc(efx->symkey_s2k,efx->symkey_dek,
841                                     efx->cfx.dek,a);
842                 if(rc)
843                   return rc;
844               }
845             
846             iobuf_push_filter (a, cipher_filter, &efx->cfx);
847             
848             efx->header_okay = 1;
849         }
850       rc = iobuf_write (a, buf, size);
851       
852     }
853   else if (control == IOBUFCTRL_FREE)
854     {
855       xfree (efx->symkey_dek);
856       xfree (efx->symkey_s2k);
857     }
858   else if ( control == IOBUFCTRL_DESC )
859     {
860       *(char**)buf = "encrypt_filter";
861     }
862   return rc;
863 }
864
865
866 /*
867  * Write pubkey-enc packets from the list of PKs to OUT.
868  */
869 static int
870 write_pubkey_enc_from_list (PK_LIST pk_list, DEK *dek, iobuf_t out)
871 {
872   PACKET pkt;
873   PKT_public_key *pk;
874   PKT_pubkey_enc  *enc;
875   int rc;
876
877   for ( ; pk_list; pk_list = pk_list->next )
878     {
879       gcry_mpi_t frame;
880       
881       pk = pk_list->pk;
882       
883       print_pubkey_algo_note ( pk->pubkey_algo );
884       enc = xmalloc_clear ( sizeof *enc );
885       enc->pubkey_algo = pk->pubkey_algo;
886       keyid_from_pk( pk, enc->keyid );
887       enc->throw_keyid = (opt.throw_keyid || (pk_list->flags&1));
888
889       if (opt.throw_keyid && (PGP2 || PGP6 || PGP7 || PGP8))
890         {
891           log_info(_("you may not use %s while in %s mode\n"),
892                    "--throw-keyid",compliance_option_string());
893           compliance_failure();
894         }
895
896       /* Okay, what's going on: We have the session key somewhere in
897        * the structure DEK and want to encode this session key in an
898        * integer value of n bits. pubkey_nbits gives us the number of
899        * bits we have to use.  We then encode the session key in some
900        * way and we get it back in the big intger value FRAME.  Then
901        * we use FRAME, the public key PK->PKEY and the algorithm
902        * number PK->PUBKEY_ALGO and pass it to pubkey_encrypt which
903        * returns the encrypted value in the array ENC->DATA.  This
904        * array has a size which depends on the used algorithm (e.g. 2
905        * for Elgamal).  We don't need frame anymore because we have
906        * everything now in enc->data which is the passed to
907        * build_packet().  */
908       frame = encode_session_key (dek, 
909                                   pubkey_nbits (pk->pubkey_algo, pk->pkey));
910       rc = pk_encrypt (pk->pubkey_algo, enc->data, frame, pk->pkey);
911       gcry_mpi_release (frame);
912       if (rc)
913         log_error ("pubkey_encrypt failed: %s\n", gpg_strerror (rc) );
914       else
915         {
916           if ( opt.verbose )
917             {
918               char *ustr = get_user_id_string_native (enc->keyid);
919               log_info (_("%s/%s encrypted for: \"%s\"\n"),
920                         gcry_pk_algo_name (enc->pubkey_algo),
921                         openpgp_cipher_algo_name (dek->algo),
922                         ustr );
923               xfree (ustr);
924             }
925           /* And write it. */
926           init_packet (&pkt);
927           pkt.pkttype = PKT_PUBKEY_ENC;
928           pkt.pkt.pubkey_enc = enc;
929           rc = build_packet (out, &pkt);
930           if (rc)
931             log_error ("build_packet(pubkey_enc) failed: %s\n", 
932                        g10_errstr (rc));
933         }
934       free_pubkey_enc(enc);
935       if (rc)
936         return rc;
937     }
938   return 0;
939 }
940
941
942 void
943 encrypt_crypt_files (int nfiles, char **files, strlist_t remusr)
944 {
945   int rc = 0;
946
947   if (opt.outfile)
948     {
949       log_error(_("--output doesn't work for this command\n"));
950       return;        
951     }
952     
953   if (!nfiles)
954     {
955       char line[2048];
956       unsigned int lno = 0;
957       while ( fgets(line, DIM(line), stdin) )
958         {
959           lno++;
960           if (!*line || line[strlen(line)-1] != '\n')
961             {
962               log_error("input line %u too long or missing LF\n", lno);
963               return;
964             }
965           line[strlen(line)-1] = '\0';
966           print_file_status(STATUS_FILE_START, line, 2);
967           rc = encrypt_crypt (GNUPG_INVALID_FD, line, remusr, 0,
968                               NULL, GNUPG_INVALID_FD);
969           if (rc)
970             log_error ("encryption of `%s' failed: %s\n",
971                        print_fname_stdin(line), g10_errstr(rc) );
972           write_status( STATUS_FILE_DONE );
973         }
974     }
975   else
976     {
977       while (nfiles--)
978         {
979           print_file_status(STATUS_FILE_START, *files, 2);
980           if ( (rc = encrypt_crypt (GNUPG_INVALID_FD, *files, remusr, 0,
981                                     NULL, GNUPG_INVALID_FD)) )
982             log_error("encryption of `%s' failed: %s\n",
983                       print_fname_stdin(*files), g10_errstr(rc) );
984           write_status( STATUS_FILE_DONE );
985           files++;
986         }
987     }
988 }