Silence several warnings when building under Windows.
[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, IOBUF_IOCTL_NO_CACHE, 1, NULL);
189   if (inp && is_secured_file (iobuf_get_fd (inp)))
190     {
191       iobuf_close (inp);
192       inp = NULL;
193       gpg_err_set_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 (-1, filename, opt.armor? 1:0, &out )))
268     {
269       iobuf_cancel (inp);
270       xfree (cfx.dek);
271       xfree (s2k);
272       release_progress_context (pfx);
273       return rc;
274     }
275
276   if ( opt.armor )
277     {
278       afx = new_armor_context ();
279       push_armor_filter (afx, out);
280     }
281
282   if ( s2k && !RFC1991 )
283     {
284       PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc + seskeylen + 1 );
285       enc->version = 4;
286       enc->cipher_algo = cfx.dek->algo;
287       enc->s2k = *s2k;
288       if ( use_seskey && seskeylen )
289         {
290           enc->seskeylen = seskeylen + 1; /* algo id */
291           memcpy (enc->seskey, enckey, seskeylen + 1 );
292         }
293       pkt.pkttype = PKT_SYMKEY_ENC;
294       pkt.pkt.symkey_enc = enc;
295       if ((rc = build_packet( out, &pkt )))
296         log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
297       xfree (enc);
298     }
299
300   if (!opt.no_literal)
301     pt = setup_plaintext_name (filename, inp);
302
303   /* Note that PGP 5 has problems decrypting symmetrically encrypted
304      data if the file length is in the inner packet. It works when
305      only partial length headers are use.  In the past, we always used
306      partial body length here, but since PGP 2, PGP 6, and PGP 7 need
307      the file length, and nobody should be using PGP 5 nowadays
308      anyway, this is now set to the file length.  Note also that this
309      only applies to the RFC-1991 style symmetric messages, and not
310      the RFC-2440 style.  PGP 6 and 7 work with either partial length
311      or fixed length with the new style messages. */
312
313   if ( !iobuf_is_pipe_filename (filename) && *filename && !opt.textmode )
314     {
315       off_t tmpsize;
316       int overflow;
317
318       if ( !(tmpsize = iobuf_get_filelength(inp, &overflow))
319            && !overflow && opt.verbose)
320         log_info(_("WARNING: '%s' is an empty file\n"), filename );
321       /* We can't encode the length of very large files because
322          OpenPGP uses only 32 bit for file sizes.  So if the the
323          size of a file is larger than 2^32 minus some bytes for
324          packet headers, we switch to partial length encoding. */
325       if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
326         filesize = tmpsize;
327       else
328         filesize = 0;
329     }
330   else
331     filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
332
333   if (!opt.no_literal)
334     {
335       pt->timestamp = make_timestamp();
336       pt->mode = opt.textmode? 't' : 'b';
337       pt->len = filesize;
338       pt->new_ctb = !pt->len && !RFC1991;
339       pt->buf = inp;
340       pkt.pkttype = PKT_PLAINTEXT;
341       pkt.pkt.plaintext = pt;
342       cfx.datalen = filesize && !do_compress ? calc_packet_length( &pkt ) : 0;
343     }
344   else
345     {
346       cfx.datalen = filesize && !do_compress ? filesize : 0;
347       pkt.pkttype = 0;
348       pkt.pkt.generic = NULL;
349     }
350
351   /* Register the cipher filter. */
352   if (mode)
353     iobuf_push_filter ( out, cipher_filter, &cfx );
354
355   /* Register the compress filter. */
356   if ( do_compress )
357     {
358       if (cfx.dek && cfx.dek->use_mdc)
359         zfx.new_ctb = 1;
360       push_compress_filter (out, &zfx, default_compress_algo());
361     }
362
363   /* Do the work. */
364   if (!opt.no_literal)
365     {
366       if ( (rc = build_packet( out, &pkt )) )
367         log_error("build_packet failed: %s\n", g10_errstr(rc) );
368     }
369   else
370     {
371       /* User requested not to create a literal packet, so we copy the
372          plain data.  */
373     byte copy_buffer[4096];
374     int  bytes_copied;
375     while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
376       if ( (rc=iobuf_write(out, copy_buffer, bytes_copied)) ) {
377         log_error ("copying input to output failed: %s\n",
378                    gpg_strerror (rc) );
379         break;
380       }
381     wipememory (copy_buffer, 4096); /* burn buffer */
382     }
383
384   /* Finish the stuff.  */
385   iobuf_close (inp);
386   if (rc)
387     iobuf_cancel(out);
388   else
389     {
390       iobuf_close (out); /* fixme: check returncode */
391       if (mode)
392         write_status ( STATUS_END_ENCRYPTION );
393     }
394   if (pt)
395     pt->buf = NULL;
396   free_packet (&pkt);
397   xfree (cfx.dek);
398   xfree (s2k);
399   release_armor_context (afx);
400   release_progress_context (pfx);
401   return rc;
402 }
403
404
405 int
406 setup_symkey (STRING2KEY **symkey_s2k,DEK **symkey_dek)
407 {
408   int canceled;
409
410   *symkey_s2k=xmalloc_clear(sizeof(STRING2KEY));
411   (*symkey_s2k)->mode = opt.s2k_mode;
412   (*symkey_s2k)->hash_algo = S2K_DIGEST_ALGO;
413
414   *symkey_dek=passphrase_to_dek(NULL,0,opt.s2k_cipher_algo,
415                                 *symkey_s2k, 4, NULL, &canceled);
416   if(!*symkey_dek || !(*symkey_dek)->keylen)
417     {
418       xfree(*symkey_dek);
419       xfree(*symkey_s2k);
420       return gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
421     }
422
423   return 0;
424 }
425
426
427 static int
428 write_symkey_enc (STRING2KEY *symkey_s2k, DEK *symkey_dek, DEK *dek,
429                   iobuf_t out)
430 {
431   int rc, seskeylen = openpgp_cipher_get_algo_keylen (dek->algo);
432
433   PKT_symkey_enc *enc;
434   byte enckey[33];
435   PACKET pkt;
436
437   enc=xmalloc_clear(sizeof(PKT_symkey_enc)+seskeylen+1);
438   encrypt_seskey(symkey_dek,&dek,enckey);
439
440   enc->version = 4;
441   enc->cipher_algo = opt.s2k_cipher_algo;
442   enc->s2k = *symkey_s2k;
443   enc->seskeylen = seskeylen + 1; /* algo id */
444   memcpy( enc->seskey, enckey, seskeylen + 1 );
445
446   pkt.pkttype = PKT_SYMKEY_ENC;
447   pkt.pkt.symkey_enc = enc;
448
449   if ((rc=build_packet(out,&pkt)))
450     log_error("build symkey_enc packet failed: %s\n",g10_errstr(rc));
451
452   xfree(enc);
453   return rc;
454 }
455
456
457 /*
458  * Encrypt the file with the given userids (or ask if none is
459  * supplied).  Either FILENAME or FILEFD must be given, but not both.
460  * The caller may provide a checked list of public keys in
461  * PROVIDED_PKS; if not the function builds a list of keys on its own.
462  */
463 int
464 encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
465                strlist_t remusr, int use_symkey, pk_list_t provided_keys,
466                int outputfd)
467 {
468   iobuf_t inp = NULL;
469   iobuf_t out = NULL;
470   PACKET pkt;
471   PKT_plaintext *pt = NULL;
472   DEK *symkey_dek = NULL;
473   STRING2KEY *symkey_s2k = NULL;
474   int rc = 0, rc2 = 0;
475   u32 filesize;
476   cipher_filter_context_t cfx;
477   armor_filter_context_t *afx = NULL;
478   compress_filter_context_t zfx;
479   text_filter_context_t tfx;
480   progress_filter_context_t *pfx;
481   PK_LIST pk_list, work_list;
482   int do_compress;
483
484   if (filefd != -1 && filename)
485     return gpg_error (GPG_ERR_INV_ARG);
486
487   do_compress = opt.compress_algo && !RFC1991;
488
489   pfx = new_progress_context ();
490   memset( &cfx, 0, sizeof cfx);
491   memset( &zfx, 0, sizeof zfx);
492   memset( &tfx, 0, sizeof tfx);
493   init_packet(&pkt);
494
495   if (use_symkey
496       && (rc=setup_symkey(&symkey_s2k,&symkey_dek)))
497     {
498       release_progress_context (pfx);
499       return rc;
500     }
501
502   if (provided_keys)
503     pk_list = provided_keys;
504   else
505     {
506       if ((rc = build_pk_list (ctrl, remusr, &pk_list, PUBKEY_USAGE_ENC)))
507         {
508           release_progress_context (pfx);
509           return rc;
510         }
511     }
512
513   if(PGP2)
514     {
515       for (work_list=pk_list; work_list; work_list=work_list->next)
516         if (!(is_RSA (work_list->pk->pubkey_algo)
517               && nbits_from_pk (work_list->pk) <= 2048))
518           {
519             log_info(_("you can only encrypt to RSA keys of 2048 bits or "
520                        "less in --pgp2 mode\n"));
521             compliance_failure();
522             break;
523           }
524     }
525
526   /* Prepare iobufs. */
527 #ifdef HAVE_W32_SYSTEM
528   if (filefd == -1)
529     inp = iobuf_open_fd_or_name (GNUPG_INVALID_FD, filename, "rb");
530   else
531     {
532       inp = NULL;
533       gpg_err_set_errno (ENOSYS);
534     }
535 #else
536   inp = iobuf_open_fd_or_name (filefd, filename, "rb");
537 #endif
538   if (inp)
539     iobuf_ioctl (inp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
540   if (inp && is_secured_file (iobuf_get_fd (inp)))
541     {
542       iobuf_close (inp);
543       inp = NULL;
544       gpg_err_set_errno (EPERM);
545     }
546   if (!inp)
547     {
548       char xname[64];
549
550       rc = gpg_error_from_syserror ();
551       if (filefd != -1)
552         snprintf (xname, sizeof xname, "[fd %d]", filefd);
553       else if (!filename)
554         strcpy (xname, "[stdin]");
555       else
556         *xname = 0;
557       log_error (_("can't open '%s': %s\n"),
558                  *xname? xname : filename, gpg_strerror (rc) );
559       goto leave;
560     }
561
562   if (opt.verbose)
563     log_info (_("reading from '%s'\n"), iobuf_get_fname_nonnull (inp));
564
565   handle_progress (pfx, inp, filename);
566
567   if (opt.textmode)
568     iobuf_push_filter (inp, text_filter, &tfx);
569
570   rc = open_outfile (outputfd, filename, opt.armor? 1:0, &out);
571   if (rc)
572     goto leave;
573
574   if (opt.armor)
575     {
576       afx = new_armor_context ();
577       push_armor_filter (afx, out);
578     }
579
580   /* Create a session key. */
581   cfx.dek = xmalloc_secure_clear (sizeof *cfx.dek);
582   if (!opt.def_cipher_algo)
583     {
584       /* Try to get it from the prefs.  */
585       cfx.dek->algo = select_algo_from_prefs (pk_list, PREFTYPE_SYM, -1, NULL);
586       /* The only way select_algo_from_prefs can fail here is when
587          mixing v3 and v4 keys, as v4 keys have an implicit preference
588          entry for 3DES, and the pk_list cannot be empty.  In this
589          case, use 3DES anyway as it's the safest choice - perhaps the
590          v3 key is being used in an OpenPGP implementation and we know
591          that the implementation behind any v4 key can handle 3DES. */
592       if (cfx.dek->algo == -1)
593         {
594           cfx.dek->algo = CIPHER_ALGO_3DES;
595
596           if (PGP2)
597             {
598               log_info(_("unable to use the IDEA cipher for all of the keys "
599                          "you are encrypting to.\n"));
600               compliance_failure();
601             }
602         }
603
604       /* In case 3DES has been selected, print a warning if any key
605          does not have a preference for AES.  This should help to
606          indentify why encrypting to several recipients falls back to
607          3DES. */
608       if (opt.verbose && cfx.dek->algo == CIPHER_ALGO_3DES)
609         warn_missing_aes_from_pklist (pk_list);
610     }
611   else
612     {
613       if (!opt.expert
614           && (select_algo_from_prefs (pk_list, PREFTYPE_SYM,
615                                       opt.def_cipher_algo, NULL)
616               != opt.def_cipher_algo))
617         {
618           log_info(_("WARNING: forcing symmetric cipher %s (%d)"
619                      " violates recipient preferences\n"),
620                    openpgp_cipher_algo_name (opt.def_cipher_algo),
621                    opt.def_cipher_algo);
622         }
623
624       cfx.dek->algo = opt.def_cipher_algo;
625     }
626
627   cfx.dek->use_mdc = use_mdc (pk_list,cfx.dek->algo);
628
629   /* Only do the is-file-already-compressed check if we are using a
630      MDC.  This forces compressed files to be re-compressed if we do
631      not have a MDC to give some protection against chosen ciphertext
632      attacks. */
633
634   if (do_compress && cfx.dek->use_mdc && is_file_compressed(filename, &rc2))
635     {
636       if (opt.verbose)
637         log_info(_("'%s' already compressed\n"), filename);
638       do_compress = 0;
639     }
640   if (rc2)
641     {
642       rc = rc2;
643       goto leave;
644     }
645
646   make_session_key (cfx.dek);
647   if (DBG_CIPHER)
648     log_printhex ("DEK is: ", cfx.dek->key, cfx.dek->keylen );
649
650   rc = write_pubkey_enc_from_list (pk_list, cfx.dek, out);
651   if (rc)
652     goto leave;
653
654   /* We put the passphrase (if any) after any public keys as this
655      seems to be the most useful on the recipient side - there is no
656      point in prompting a user for a passphrase if they have the
657      secret key needed to decrypt.  */
658   if(use_symkey && (rc = write_symkey_enc(symkey_s2k,symkey_dek,cfx.dek,out)))
659     goto leave;
660
661   if (!opt.no_literal)
662     pt = setup_plaintext_name (filename, inp);
663
664   if (filefd != -1
665       && !iobuf_is_pipe_filename (filename) && *filename && !opt.textmode )
666     {
667       off_t tmpsize;
668       int overflow;
669
670       if ( !(tmpsize = iobuf_get_filelength(inp, &overflow))
671            && !overflow && opt.verbose)
672         log_info(_("WARNING: '%s' is an empty file\n"), filename );
673       /* We can't encode the length of very large files because
674          OpenPGP uses only 32 bit for file sizes.  So if the the size
675          of a file is larger than 2^32 minus some bytes for packet
676          headers, we switch to partial length encoding. */
677       if (tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
678         filesize = tmpsize;
679       else
680         filesize = 0;
681     }
682   else
683     filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
684
685   if (!opt.no_literal)
686     {
687       pt->timestamp = make_timestamp();
688       pt->mode = opt.textmode ? 't' : 'b';
689       pt->len = filesize;
690       pt->new_ctb = !pt->len && !RFC1991;
691       pt->buf = inp;
692       pkt.pkttype = PKT_PLAINTEXT;
693       pkt.pkt.plaintext = pt;
694       cfx.datalen = filesize && !do_compress? calc_packet_length( &pkt ) : 0;
695     }
696   else
697     cfx.datalen = filesize && !do_compress ? filesize : 0;
698
699   /* Register the cipher filter. */
700   iobuf_push_filter (out, cipher_filter, &cfx);
701
702   /* Register the compress filter. */
703   if (do_compress)
704     {
705       int compr_algo = opt.compress_algo;
706
707       if (compr_algo == -1)
708         {
709           compr_algo = select_algo_from_prefs (pk_list, PREFTYPE_ZIP, -1, NULL);
710           if (compr_algo == -1)
711             compr_algo = DEFAULT_COMPRESS_ALGO;
712           /* Theoretically impossible to get here since uncompressed
713              is implicit.  */
714         }
715       else if (!opt.expert
716                && select_algo_from_prefs(pk_list, PREFTYPE_ZIP,
717                                          compr_algo, NULL) != compr_algo)
718         {
719           log_info (_("WARNING: forcing compression algorithm %s (%d)"
720                       " violates recipient preferences\n"),
721                     compress_algo_to_string(compr_algo), compr_algo);
722         }
723
724       /* Algo 0 means no compression. */
725       if (compr_algo)
726         {
727           if (cfx.dek && cfx.dek->use_mdc)
728             zfx.new_ctb = 1;
729           push_compress_filter (out,&zfx,compr_algo);
730         }
731     }
732
733   /* Do the work. */
734   if (!opt.no_literal)
735     {
736       if ((rc = build_packet( out, &pkt )))
737         log_error ("build_packet failed: %s\n", g10_errstr(rc));
738     }
739   else
740     {
741       /* User requested not to create a literal packet, so we copy the
742          plain data. */
743       byte copy_buffer[4096];
744       int  bytes_copied;
745       while ((bytes_copied = iobuf_read (inp, copy_buffer, 4096)) != -1)
746         {
747           rc = iobuf_write (out, copy_buffer, bytes_copied);
748           if (rc)
749             {
750               log_error ("copying input to output failed: %s\n",
751                          gpg_strerror (rc));
752               break;
753             }
754         }
755       wipememory (copy_buffer, 4096); /* Burn the buffer. */
756     }
757
758   /* Finish the stuff. */
759  leave:
760   iobuf_close (inp);
761   if (rc)
762     iobuf_cancel (out);
763   else
764     {
765       iobuf_close (out); /* fixme: check returncode */
766       write_status (STATUS_END_ENCRYPTION);
767     }
768   if (pt)
769     pt->buf = NULL;
770   free_packet (&pkt);
771   xfree (cfx.dek);
772   xfree (symkey_dek);
773   xfree (symkey_s2k);
774   if (!provided_keys)
775     release_pk_list (pk_list);
776   release_armor_context (afx);
777   release_progress_context (pfx);
778   return rc;
779 }
780
781
782 /*
783  * Filter to do a complete public key encryption.
784  */
785 int
786 encrypt_filter (void *opaque, int control,
787                 iobuf_t a, byte *buf, size_t *ret_len)
788 {
789   size_t size = *ret_len;
790   encrypt_filter_context_t *efx = opaque;
791   int rc = 0;
792
793   if (control == IOBUFCTRL_UNDERFLOW) /* decrypt */
794     {
795       BUG(); /* not used */
796     }
797   else if ( control == IOBUFCTRL_FLUSH ) /* encrypt */
798     {
799       if ( !efx->header_okay )
800         {
801           efx->cfx.dek = xmalloc_secure_clear ( sizeof *efx->cfx.dek );
802           if ( !opt.def_cipher_algo  )
803             {
804               /* Try to get it from the prefs. */
805               efx->cfx.dek->algo =
806                 select_algo_from_prefs (efx->pk_list, PREFTYPE_SYM, -1, NULL);
807               if (efx->cfx.dek->algo == -1 )
808                 {
809                   /* Because 3DES is implicitly in the prefs, this can
810                      only happen if we do not have any public keys in
811                      the list.  */
812                   efx->cfx.dek->algo = DEFAULT_CIPHER_ALGO;
813                 }
814
815               /* In case 3DES has been selected, print a warning if
816                  any key does not have a preference for AES.  This
817                  should help to indentify why encrypting to several
818                  recipients falls back to 3DES. */
819               if (opt.verbose
820                   && efx->cfx.dek->algo == CIPHER_ALGO_3DES)
821                 warn_missing_aes_from_pklist (efx->pk_list);
822             }
823           else
824             {
825               if (!opt.expert
826                   && select_algo_from_prefs (efx->pk_list,PREFTYPE_SYM,
827                                              opt.def_cipher_algo,
828                                              NULL) != opt.def_cipher_algo)
829                 log_info(_("forcing symmetric cipher %s (%d) "
830                            "violates recipient preferences\n"),
831                          openpgp_cipher_algo_name (opt.def_cipher_algo),
832                          opt.def_cipher_algo);
833
834               efx->cfx.dek->algo = opt.def_cipher_algo;
835             }
836
837           efx->cfx.dek->use_mdc = use_mdc (efx->pk_list,efx->cfx.dek->algo);
838
839           make_session_key ( efx->cfx.dek );
840           if (DBG_CIPHER)
841             log_printhex ("DEK is: ", efx->cfx.dek->key, efx->cfx.dek->keylen);
842
843           rc = write_pubkey_enc_from_list (efx->pk_list, efx->cfx.dek, a);
844           if (rc)
845             return rc;
846
847             if(efx->symkey_s2k && efx->symkey_dek)
848               {
849                 rc=write_symkey_enc(efx->symkey_s2k,efx->symkey_dek,
850                                     efx->cfx.dek,a);
851                 if(rc)
852                   return rc;
853               }
854
855             iobuf_push_filter (a, cipher_filter, &efx->cfx);
856
857             efx->header_okay = 1;
858         }
859       rc = iobuf_write (a, buf, size);
860
861     }
862   else if (control == IOBUFCTRL_FREE)
863     {
864       xfree (efx->symkey_dek);
865       xfree (efx->symkey_s2k);
866     }
867   else if ( control == IOBUFCTRL_DESC )
868     {
869       *(char**)buf = "encrypt_filter";
870     }
871   return rc;
872 }
873
874
875 /*
876  * Write pubkey-enc packets from the list of PKs to OUT.
877  */
878 static int
879 write_pubkey_enc_from_list (PK_LIST pk_list, DEK *dek, iobuf_t out)
880 {
881   PACKET pkt;
882   PKT_public_key *pk;
883   PKT_pubkey_enc  *enc;
884   int rc;
885
886   for ( ; pk_list; pk_list = pk_list->next )
887     {
888       gcry_mpi_t frame;
889
890       pk = pk_list->pk;
891
892       print_pubkey_algo_note ( pk->pubkey_algo );
893       enc = xmalloc_clear ( sizeof *enc );
894       enc->pubkey_algo = pk->pubkey_algo;
895       keyid_from_pk( pk, enc->keyid );
896       enc->throw_keyid = (opt.throw_keyid || (pk_list->flags&1));
897
898       if (opt.throw_keyid && (PGP2 || PGP6 || PGP7 || PGP8))
899         {
900           log_info(_("you may not use %s while in %s mode\n"),
901                    "--throw-keyid",compliance_option_string());
902           compliance_failure();
903         }
904
905       /* Okay, what's going on: We have the session key somewhere in
906        * the structure DEK and want to encode this session key in an
907        * integer value of n bits. pubkey_nbits gives us the number of
908        * bits we have to use.  We then encode the session key in some
909        * way and we get it back in the big intger value FRAME.  Then
910        * we use FRAME, the public key PK->PKEY and the algorithm
911        * number PK->PUBKEY_ALGO and pass it to pubkey_encrypt which
912        * returns the encrypted value in the array ENC->DATA.  This
913        * array has a size which depends on the used algorithm (e.g. 2
914        * for Elgamal).  We don't need frame anymore because we have
915        * everything now in enc->data which is the passed to
916        * build_packet().  */
917       frame = encode_session_key (pk->pubkey_algo, dek,
918                                   pubkey_nbits (pk->pubkey_algo, pk->pkey));
919       rc = pk_encrypt (pk->pubkey_algo, enc->data, frame, pk, pk->pkey);
920       gcry_mpi_release (frame);
921       if (rc)
922         log_error ("pubkey_encrypt failed: %s\n", gpg_strerror (rc) );
923       else
924         {
925           if ( opt.verbose )
926             {
927               char *ustr = get_user_id_string_native (enc->keyid);
928               log_info (_("%s/%s encrypted for: \"%s\"\n"),
929                         openpgp_pk_algo_name (enc->pubkey_algo),
930                         openpgp_cipher_algo_name (dek->algo),
931                         ustr );
932               xfree (ustr);
933             }
934           /* And write it. */
935           init_packet (&pkt);
936           pkt.pkttype = PKT_PUBKEY_ENC;
937           pkt.pkt.pubkey_enc = enc;
938           rc = build_packet (out, &pkt);
939           if (rc)
940             log_error ("build_packet(pubkey_enc) failed: %s\n",
941                        g10_errstr (rc));
942         }
943       free_pubkey_enc(enc);
944       if (rc)
945         return rc;
946     }
947   return 0;
948 }
949
950
951 void
952 encrypt_crypt_files (ctrl_t ctrl, int nfiles, char **files, strlist_t remusr)
953 {
954   int rc = 0;
955
956   if (opt.outfile)
957     {
958       log_error(_("--output doesn't work for this command\n"));
959       return;
960     }
961
962   if (!nfiles)
963     {
964       char line[2048];
965       unsigned int lno = 0;
966       while ( fgets(line, DIM(line), stdin) )
967         {
968           lno++;
969           if (!*line || line[strlen(line)-1] != '\n')
970             {
971               log_error("input line %u too long or missing LF\n", lno);
972               return;
973             }
974           line[strlen(line)-1] = '\0';
975           print_file_status(STATUS_FILE_START, line, 2);
976           rc = encrypt_crypt (ctrl, -1, line, remusr, 0, NULL, -1);
977           if (rc)
978             log_error ("encryption of '%s' failed: %s\n",
979                        print_fname_stdin(line), g10_errstr(rc) );
980           write_status( STATUS_FILE_DONE );
981         }
982     }
983   else
984     {
985       while (nfiles--)
986         {
987           print_file_status(STATUS_FILE_START, *files, 2);
988           if ( (rc = encrypt_crypt (ctrl, -1, *files, remusr, 0, NULL, -1)) )
989             log_error("encryption of '%s' failed: %s\n",
990                       print_fname_stdin(*files), g10_errstr(rc) );
991           write_status( STATUS_FILE_DONE );
992           files++;
993         }
994     }
995 }