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