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