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