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