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