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