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