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