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