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