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