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