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