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