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