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