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