gpg: When comparing keyids, use the keyid, not the fingerprint's suffix.
[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 function,
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 int
105 use_mdc (pk_list_t 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 (filename);
514   else
515     {
516       inp = NULL;
517       gpg_err_set_errno (ENOSYS);
518     }
519 #else
520   if (filefd == GNUPG_INVALID_FD)
521     inp = iobuf_open (filename);
522   else
523     inp = iobuf_fdopen_nc (FD2INT(filefd), "rb");
524 #endif
525   if (inp)
526     iobuf_ioctl (inp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
527   if (inp && is_secured_file (iobuf_get_fd (inp)))
528     {
529       iobuf_close (inp);
530       inp = NULL;
531       gpg_err_set_errno (EPERM);
532     }
533   if (!inp)
534     {
535       char xname[64];
536
537       rc = gpg_error_from_syserror ();
538       if (filefd != -1)
539         snprintf (xname, sizeof xname, "[fd %d]", filefd);
540       else if (!filename)
541         strcpy (xname, "[stdin]");
542       else
543         *xname = 0;
544       log_error (_("can't open '%s': %s\n"),
545                  *xname? xname : filename, gpg_strerror (rc) );
546       goto leave;
547     }
548
549   if (opt.verbose)
550     log_info (_("reading from '%s'\n"), iobuf_get_fname_nonnull (inp));
551
552   handle_progress (pfx, inp, filename);
553
554   if (opt.textmode)
555     iobuf_push_filter (inp, text_filter, &tfx);
556
557   rc = open_outfile (outputfd, filename, opt.armor? 1:0, 0, &out);
558   if (rc)
559     goto leave;
560
561   if (opt.armor)
562     {
563       afx = new_armor_context ();
564       push_armor_filter (afx, out);
565     }
566
567   /* Create a session key. */
568   cfx.dek = xmalloc_secure_clear (sizeof *cfx.dek);
569   if (!opt.def_cipher_algo)
570     {
571       /* Try to get it from the prefs.  */
572       cfx.dek->algo = select_algo_from_prefs (pk_list, PREFTYPE_SYM, -1, NULL);
573       /* The only way select_algo_from_prefs can fail here is when
574          mixing v3 and v4 keys, as v4 keys have an implicit preference
575          entry for 3DES, and the pk_list cannot be empty.  In this
576          case, use 3DES anyway as it's the safest choice - perhaps the
577          v3 key is being used in an OpenPGP implementation and we know
578          that the implementation behind any v4 key can handle 3DES. */
579       if (cfx.dek->algo == -1)
580         {
581           cfx.dek->algo = CIPHER_ALGO_3DES;
582         }
583
584       /* In case 3DES has been selected, print a warning if any key
585          does not have a preference for AES.  This should help to
586          indentify why encrypting to several recipients falls back to
587          3DES. */
588       if (opt.verbose && cfx.dek->algo == CIPHER_ALGO_3DES)
589         warn_missing_aes_from_pklist (pk_list);
590     }
591   else
592     {
593       if (!opt.expert
594           && (select_algo_from_prefs (pk_list, PREFTYPE_SYM,
595                                       opt.def_cipher_algo, NULL)
596               != opt.def_cipher_algo))
597         {
598           log_info(_("WARNING: forcing symmetric cipher %s (%d)"
599                      " violates recipient preferences\n"),
600                    openpgp_cipher_algo_name (opt.def_cipher_algo),
601                    opt.def_cipher_algo);
602         }
603
604       cfx.dek->algo = opt.def_cipher_algo;
605     }
606
607   cfx.dek->use_mdc = use_mdc (pk_list,cfx.dek->algo);
608
609   /* Only do the is-file-already-compressed check if we are using a
610      MDC.  This forces compressed files to be re-compressed if we do
611      not have a MDC to give some protection against chosen ciphertext
612      attacks. */
613
614   if (do_compress && cfx.dek->use_mdc && is_file_compressed(filename, &rc2))
615     {
616       if (opt.verbose)
617         log_info(_("'%s' already compressed\n"), filename);
618       do_compress = 0;
619     }
620   if (rc2)
621     {
622       rc = rc2;
623       goto leave;
624     }
625
626   make_session_key (cfx.dek);
627   if (DBG_CRYPTO)
628     log_printhex ("DEK is: ", cfx.dek->key, cfx.dek->keylen );
629
630   rc = write_pubkey_enc_from_list (pk_list, cfx.dek, out);
631   if (rc)
632     goto leave;
633
634   /* We put the passphrase (if any) after any public keys as this
635      seems to be the most useful on the recipient side - there is no
636      point in prompting a user for a passphrase if they have the
637      secret key needed to decrypt.  */
638   if(use_symkey && (rc = write_symkey_enc(symkey_s2k,symkey_dek,cfx.dek,out)))
639     goto leave;
640
641   if (!opt.no_literal)
642     pt = setup_plaintext_name (filename, inp);
643
644   /* Get the size of the file if possible, i.e., if it is a real file.  */
645   if (filename && *filename
646       && !iobuf_is_pipe_filename (filename) && !opt.textmode )
647     {
648       off_t tmpsize;
649       int overflow;
650
651       if ( !(tmpsize = iobuf_get_filelength(inp, &overflow))
652            && !overflow && opt.verbose)
653         log_info(_("WARNING: '%s' is an empty file\n"), filename );
654       /* We can't encode the length of very large files because
655          OpenPGP uses only 32 bit for file sizes.  So if the the size
656          of a file is larger than 2^32 minus some bytes for packet
657          headers, we switch to partial length encoding. */
658       if (tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
659         filesize = tmpsize;
660       else
661         filesize = 0;
662     }
663   else
664     filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
665
666   if (!opt.no_literal)
667     {
668       pt->timestamp = make_timestamp();
669       pt->mode = opt.textmode ? 't' : 'b';
670       pt->len = filesize;
671       pt->new_ctb = !pt->len;
672       pt->buf = inp;
673       pkt.pkttype = PKT_PLAINTEXT;
674       pkt.pkt.plaintext = pt;
675       cfx.datalen = filesize && !do_compress? calc_packet_length( &pkt ) : 0;
676     }
677   else
678     cfx.datalen = filesize && !do_compress ? filesize : 0;
679
680   /* Register the cipher filter. */
681   iobuf_push_filter (out, cipher_filter, &cfx);
682
683   /* Register the compress filter. */
684   if (do_compress)
685     {
686       int compr_algo = opt.compress_algo;
687
688       if (compr_algo == -1)
689         {
690           compr_algo = select_algo_from_prefs (pk_list, PREFTYPE_ZIP, -1, NULL);
691           if (compr_algo == -1)
692             compr_algo = DEFAULT_COMPRESS_ALGO;
693           /* Theoretically impossible to get here since uncompressed
694              is implicit.  */
695         }
696       else if (!opt.expert
697                && select_algo_from_prefs(pk_list, PREFTYPE_ZIP,
698                                          compr_algo, NULL) != compr_algo)
699         {
700           log_info (_("WARNING: forcing compression algorithm %s (%d)"
701                       " violates recipient preferences\n"),
702                     compress_algo_to_string(compr_algo), compr_algo);
703         }
704
705       /* Algo 0 means no compression. */
706       if (compr_algo)
707         {
708           if (cfx.dek && cfx.dek->use_mdc)
709             zfx.new_ctb = 1;
710           push_compress_filter (out,&zfx,compr_algo);
711         }
712     }
713
714   /* Do the work. */
715   if (!opt.no_literal)
716     {
717       if ((rc = build_packet( out, &pkt )))
718         log_error ("build_packet failed: %s\n", gpg_strerror (rc));
719     }
720   else
721     {
722       /* User requested not to create a literal packet, so we copy the
723          plain data. */
724       byte copy_buffer[4096];
725       int  bytes_copied;
726       while ((bytes_copied = iobuf_read (inp, copy_buffer, 4096)) != -1)
727         {
728           rc = iobuf_write (out, copy_buffer, bytes_copied);
729           if (rc)
730             {
731               log_error ("copying input to output failed: %s\n",
732                          gpg_strerror (rc));
733               break;
734             }
735         }
736       wipememory (copy_buffer, 4096); /* Burn the buffer. */
737     }
738
739   /* Finish the stuff. */
740  leave:
741   iobuf_close (inp);
742   if (rc)
743     iobuf_cancel (out);
744   else
745     {
746       iobuf_close (out); /* fixme: check returncode */
747       write_status (STATUS_END_ENCRYPTION);
748     }
749   if (pt)
750     pt->buf = NULL;
751   free_packet (&pkt);
752   xfree (cfx.dek);
753   xfree (symkey_dek);
754   xfree (symkey_s2k);
755   if (!provided_keys)
756     release_pk_list (pk_list);
757   release_armor_context (afx);
758   release_progress_context (pfx);
759   return rc;
760 }
761
762
763 /*
764  * Filter to do a complete public key encryption.
765  */
766 int
767 encrypt_filter (void *opaque, int control,
768                 iobuf_t a, byte *buf, size_t *ret_len)
769 {
770   size_t size = *ret_len;
771   encrypt_filter_context_t *efx = opaque;
772   int rc = 0;
773
774   if (control == IOBUFCTRL_UNDERFLOW) /* decrypt */
775     {
776       BUG(); /* not used */
777     }
778   else if ( control == IOBUFCTRL_FLUSH ) /* encrypt */
779     {
780       if ( !efx->header_okay )
781         {
782           efx->cfx.dek = xmalloc_secure_clear ( sizeof *efx->cfx.dek );
783           if ( !opt.def_cipher_algo  )
784             {
785               /* Try to get it from the prefs. */
786               efx->cfx.dek->algo =
787                 select_algo_from_prefs (efx->pk_list, PREFTYPE_SYM, -1, NULL);
788               if (efx->cfx.dek->algo == -1 )
789                 {
790                   /* Because 3DES is implicitly in the prefs, this can
791                      only happen if we do not have any public keys in
792                      the list.  */
793                   efx->cfx.dek->algo = DEFAULT_CIPHER_ALGO;
794                 }
795
796               /* In case 3DES has been selected, print a warning if
797                  any key does not have a preference for AES.  This
798                  should help to indentify why encrypting to several
799                  recipients falls back to 3DES. */
800               if (opt.verbose
801                   && efx->cfx.dek->algo == CIPHER_ALGO_3DES)
802                 warn_missing_aes_from_pklist (efx->pk_list);
803             }
804           else
805             {
806               if (!opt.expert
807                   && select_algo_from_prefs (efx->pk_list,PREFTYPE_SYM,
808                                              opt.def_cipher_algo,
809                                              NULL) != opt.def_cipher_algo)
810                 log_info(_("forcing symmetric cipher %s (%d) "
811                            "violates recipient preferences\n"),
812                          openpgp_cipher_algo_name (opt.def_cipher_algo),
813                          opt.def_cipher_algo);
814
815               efx->cfx.dek->algo = opt.def_cipher_algo;
816             }
817
818           efx->cfx.dek->use_mdc = use_mdc (efx->pk_list,efx->cfx.dek->algo);
819
820           make_session_key ( efx->cfx.dek );
821           if (DBG_CRYPTO)
822             log_printhex ("DEK is: ", efx->cfx.dek->key, efx->cfx.dek->keylen);
823
824           rc = write_pubkey_enc_from_list (efx->pk_list, efx->cfx.dek, a);
825           if (rc)
826             return rc;
827
828             if(efx->symkey_s2k && efx->symkey_dek)
829               {
830                 rc=write_symkey_enc(efx->symkey_s2k,efx->symkey_dek,
831                                     efx->cfx.dek,a);
832                 if(rc)
833                   return rc;
834               }
835
836             iobuf_push_filter (a, cipher_filter, &efx->cfx);
837
838             efx->header_okay = 1;
839         }
840       rc = iobuf_write (a, buf, size);
841
842     }
843   else if (control == IOBUFCTRL_FREE)
844     {
845       xfree (efx->symkey_dek);
846       xfree (efx->symkey_s2k);
847     }
848   else if ( control == IOBUFCTRL_DESC )
849     {
850       *(char**)buf = "encrypt_filter";
851     }
852   return rc;
853 }
854
855
856 /*
857  * Write pubkey-enc packets from the list of PKs to OUT.
858  */
859 static int
860 write_pubkey_enc_from_list (PK_LIST pk_list, DEK *dek, iobuf_t out)
861 {
862   PACKET pkt;
863   PKT_public_key *pk;
864   PKT_pubkey_enc  *enc;
865   int rc;
866
867   for ( ; pk_list; pk_list = pk_list->next )
868     {
869       gcry_mpi_t frame;
870
871       pk = pk_list->pk;
872
873       print_pubkey_algo_note ( pk->pubkey_algo );
874       enc = xmalloc_clear ( sizeof *enc );
875       enc->pubkey_algo = pk->pubkey_algo;
876       keyid_from_pk( pk, enc->keyid );
877       enc->throw_keyid = (opt.throw_keyids || (pk_list->flags&1));
878
879       if (opt.throw_keyids && (PGP6 || PGP7 || PGP8))
880         {
881           log_info(_("you may not use %s while in %s mode\n"),
882                    "--throw-keyids",compliance_option_string());
883           compliance_failure();
884         }
885
886       /* Okay, what's going on: We have the session key somewhere in
887        * the structure DEK and want to encode this session key in an
888        * integer value of n bits. pubkey_nbits gives us the number of
889        * bits we have to use.  We then encode the session key in some
890        * way and we get it back in the big intger value FRAME.  Then
891        * we use FRAME, the public key PK->PKEY and the algorithm
892        * number PK->PUBKEY_ALGO and pass it to pubkey_encrypt which
893        * returns the encrypted value in the array ENC->DATA.  This
894        * array has a size which depends on the used algorithm (e.g. 2
895        * for Elgamal).  We don't need frame anymore because we have
896        * everything now in enc->data which is the passed to
897        * build_packet().  */
898       frame = encode_session_key (pk->pubkey_algo, dek,
899                                   pubkey_nbits (pk->pubkey_algo, pk->pkey));
900       rc = pk_encrypt (pk->pubkey_algo, enc->data, frame, pk, pk->pkey);
901       gcry_mpi_release (frame);
902       if (rc)
903         log_error ("pubkey_encrypt failed: %s\n", gpg_strerror (rc) );
904       else
905         {
906           if ( opt.verbose )
907             {
908               char *ustr = get_user_id_string_native (enc->keyid);
909               log_info (_("%s/%s encrypted for: \"%s\"\n"),
910                         openpgp_pk_algo_name (enc->pubkey_algo),
911                         openpgp_cipher_algo_name (dek->algo),
912                         ustr );
913               xfree (ustr);
914             }
915           /* And write it. */
916           init_packet (&pkt);
917           pkt.pkttype = PKT_PUBKEY_ENC;
918           pkt.pkt.pubkey_enc = enc;
919           rc = build_packet (out, &pkt);
920           if (rc)
921             log_error ("build_packet(pubkey_enc) failed: %s\n",
922                        gpg_strerror (rc));
923         }
924       free_pubkey_enc(enc);
925       if (rc)
926         return rc;
927     }
928   return 0;
929 }
930
931
932 void
933 encrypt_crypt_files (ctrl_t ctrl, int nfiles, char **files, strlist_t remusr)
934 {
935   int rc = 0;
936
937   if (opt.outfile)
938     {
939       log_error(_("--output doesn't work for this command\n"));
940       return;
941     }
942
943   if (!nfiles)
944     {
945       char line[2048];
946       unsigned int lno = 0;
947       while ( fgets(line, DIM(line), stdin) )
948         {
949           lno++;
950           if (!*line || line[strlen(line)-1] != '\n')
951             {
952               log_error("input line %u too long or missing LF\n", lno);
953               return;
954             }
955           line[strlen(line)-1] = '\0';
956           print_file_status(STATUS_FILE_START, line, 2);
957           rc = encrypt_crypt (ctrl, -1, line, remusr, 0, NULL, -1);
958           if (rc)
959             log_error ("encryption of '%s' failed: %s\n",
960                        print_fname_stdin(line), gpg_strerror (rc) );
961           write_status( STATUS_FILE_DONE );
962         }
963     }
964   else
965     {
966       while (nfiles--)
967         {
968           print_file_status(STATUS_FILE_START, *files, 2);
969           if ( (rc = encrypt_crypt (ctrl, -1, *files, remusr, 0, NULL, -1)) )
970             log_error("encryption of '%s' failed: %s\n",
971                       print_fname_stdin(*files), gpg_strerror (rc) );
972           write_status( STATUS_FILE_DONE );
973           files++;
974         }
975     }
976 }