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