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