Updated card stuff to support T=0 cards.
[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
303         if ( !(tmpsize = iobuf_get_filelength(inp)) )
304           log_info(_("WARNING: `%s' is an empty file\n"), filename );
305         /* We can't encode the length of very large files because
306            OpenPGP uses only 32 bit for file sizes.  So if the the
307            size of a file is larger than 2^32 minus some bytes for
308            packet headers, we switch to partial length encoding. */
309         if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
310           filesize = tmpsize;
311         else
312           filesize = 0;
313       }
314     else
315       filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
316
317     if (!opt.no_literal) {
318         pt->timestamp = make_timestamp();
319         pt->mode = opt.textmode? 't' : 'b';
320         pt->len = filesize;
321         pt->new_ctb = !pt->len && !RFC1991;
322         pt->buf = inp;
323         pkt.pkttype = PKT_PLAINTEXT;
324         pkt.pkt.plaintext = pt;
325         cfx.datalen = filesize && !do_compress ? calc_packet_length( &pkt ) : 0;
326     }
327     else
328       {
329         cfx.datalen = filesize && !do_compress ? filesize : 0;
330         pkt.pkttype = 0;
331         pkt.pkt.generic = NULL;
332       }
333
334     /* register the cipher filter */
335     if( mode )
336         iobuf_push_filter( out, cipher_filter, &cfx );
337     /* register the compress filter */
338     if( do_compress )
339       {
340         if (cfx.dek && cfx.dek->use_mdc)
341           zfx.new_ctb = 1;
342         push_compress_filter(out,&zfx,default_compress_algo());
343       }
344
345     /* do the work */
346     if (!opt.no_literal) {
347         if( (rc = build_packet( out, &pkt )) )
348             log_error("build_packet failed: %s\n", g10_errstr(rc) );
349     }
350     else {
351         /* user requested not to create a literal packet,
352          * so we copy the plain data */
353         byte copy_buffer[4096];
354         int  bytes_copied;
355         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
356             if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
357                 rc = G10ERR_WRITE_FILE;
358                 log_error("copying input to output failed: %s\n", g10_errstr(rc) );
359                 break;
360             }
361         wipememory(copy_buffer, 4096); /* burn buffer */
362     }
363
364     /* finish the stuff */
365     iobuf_close(inp);
366     if (rc)
367         iobuf_cancel(out);
368     else {
369         iobuf_close(out); /* fixme: check returncode */
370         if (mode)
371             write_status( STATUS_END_ENCRYPTION );
372     }
373     if (pt)
374         pt->buf = NULL;
375     free_packet(&pkt);
376     xfree(cfx.dek);
377     xfree(s2k);
378     return rc;
379 }
380
381 int
382 setup_symkey(STRING2KEY **symkey_s2k,DEK **symkey_dek)
383 {
384   *symkey_s2k=xmalloc_clear(sizeof(STRING2KEY));
385   (*symkey_s2k)->mode = opt.s2k_mode;
386   (*symkey_s2k)->hash_algo = S2K_DIGEST_ALGO;
387
388   *symkey_dek=passphrase_to_dek(NULL,0,opt.s2k_cipher_algo,
389                                 *symkey_s2k,2,NULL,NULL);
390   if(!*symkey_dek || !(*symkey_dek)->keylen)
391     {
392       xfree(*symkey_dek);
393       xfree(*symkey_s2k);
394       return G10ERR_PASSPHRASE;
395     }
396
397   return 0;
398 }
399
400 static int
401 write_symkey_enc(STRING2KEY *symkey_s2k,DEK *symkey_dek,DEK *dek,IOBUF out)
402 {
403   int rc,seskeylen=cipher_get_keylen(dek->algo)/8;
404
405   PKT_symkey_enc *enc;
406   byte enckey[33];
407   PACKET pkt;
408
409   enc=xmalloc_clear(sizeof(PKT_symkey_enc)+seskeylen+1);
410   encode_seskey(symkey_dek,&dek,enckey);
411
412   enc->version = 4;
413   enc->cipher_algo = opt.s2k_cipher_algo;
414   enc->s2k = *symkey_s2k;
415   enc->seskeylen = seskeylen + 1; /* algo id */
416   memcpy( enc->seskey, enckey, seskeylen + 1 );
417
418   pkt.pkttype = PKT_SYMKEY_ENC;
419   pkt.pkt.symkey_enc = enc;
420
421   if((rc=build_packet(out,&pkt)))
422     log_error("build symkey_enc packet failed: %s\n",g10_errstr(rc));
423
424   xfree(enc);
425   return rc;
426 }
427
428 /****************
429  * Encrypt the file with the given userids (or ask if none
430  * is supplied).
431  */
432 int
433 encode_crypt( const char *filename, STRLIST remusr, int use_symkey )
434 {
435     IOBUF inp = NULL, out = NULL;
436     PACKET pkt;
437     PKT_plaintext *pt = NULL;
438     DEK *symkey_dek = NULL;
439     STRING2KEY *symkey_s2k = NULL;
440     int rc = 0, rc2 = 0;
441     u32 filesize;
442     cipher_filter_context_t cfx;
443     armor_filter_context_t afx;
444     compress_filter_context_t zfx;
445     text_filter_context_t tfx;
446     progress_filter_context_t pfx;
447     PK_LIST pk_list,work_list;
448     int do_compress = opt.compress_algo && !RFC1991;
449
450     memset( &cfx, 0, sizeof cfx);
451     memset( &afx, 0, sizeof afx);
452     memset( &zfx, 0, sizeof zfx);
453     memset( &tfx, 0, sizeof tfx);
454     init_packet(&pkt);
455
456     if(use_symkey
457        && (rc=setup_symkey(&symkey_s2k,&symkey_dek)))
458       return rc;
459
460     if( (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC)) )
461         return rc;
462
463     if(PGP2) {
464       for(work_list=pk_list; work_list; work_list=work_list->next)
465         if(!(is_RSA(work_list->pk->pubkey_algo) &&
466              nbits_from_pk(work_list->pk)<=2048))
467           {
468             log_info(_("you can only encrypt to RSA keys of 2048 bits or "
469                        "less in --pgp2 mode\n"));
470             compliance_failure();
471             break;
472           }
473     }
474
475     /* prepare iobufs */
476     inp = iobuf_open(filename);
477     if (inp)
478       iobuf_ioctl (inp,3,1,NULL); /* disable fd caching */
479     if (inp && is_secured_file (iobuf_get_fd (inp)))
480       {
481         iobuf_close (inp);
482         inp = NULL;
483         errno = EPERM;
484       }
485     if( !inp ) {
486         log_error(_("can't open `%s': %s\n"), filename? filename: "[stdin]",
487                                         strerror(errno) );
488         rc = G10ERR_OPEN_FILE;
489         goto leave;
490     }
491     else if( opt.verbose )
492         log_info(_("reading from `%s'\n"), filename? filename: "[stdin]");
493
494     handle_progress (&pfx, inp, filename);
495
496     if( opt.textmode )
497         iobuf_push_filter( inp, text_filter, &tfx );
498
499     if( (rc = open_outfile( filename, opt.armor? 1:0, &out )) )
500         goto leave;
501
502     if( opt.armor )
503         iobuf_push_filter( out, armor_filter, &afx );
504
505     /* create a session key */
506     cfx.dek = xmalloc_secure_clear (sizeof *cfx.dek);
507     if( !opt.def_cipher_algo ) { /* try to get it from the prefs */
508         cfx.dek->algo = select_algo_from_prefs(pk_list,PREFTYPE_SYM,-1,NULL);
509         /* The only way select_algo_from_prefs can fail here is when
510            mixing v3 and v4 keys, as v4 keys have an implicit
511            preference entry for 3DES, and the pk_list cannot be empty.
512            In this case, use 3DES anyway as it's the safest choice -
513            perhaps the v3 key is being used in an OpenPGP
514            implementation and we know that the implementation behind
515            any v4 key can handle 3DES. */
516         if( cfx.dek->algo == -1 ) {
517             cfx.dek->algo = CIPHER_ALGO_3DES;
518
519             if( PGP2 ) {
520               log_info(_("unable to use the IDEA cipher for all of the keys "
521                          "you are encrypting to.\n"));
522               compliance_failure();
523             }
524         }
525     }
526     else {
527       if(!opt.expert &&
528          select_algo_from_prefs(pk_list,PREFTYPE_SYM,
529                                 opt.def_cipher_algo,NULL)!=opt.def_cipher_algo)
530         log_info(_("WARNING: forcing symmetric cipher %s (%d)"
531                    " violates recipient preferences\n"),
532                  cipher_algo_to_string(opt.def_cipher_algo),
533                  opt.def_cipher_algo);
534
535       cfx.dek->algo = opt.def_cipher_algo;
536     }
537
538     cfx.dek->use_mdc=use_mdc(pk_list,cfx.dek->algo);
539
540     /* Only do the is-file-already-compressed check if we are using a
541        MDC.  This forces compressed files to be re-compressed if we do
542        not have a MDC to give some protection against chosen
543        ciphertext attacks. */
544
545     if (do_compress && cfx.dek->use_mdc && is_file_compressed(filename, &rc2) )
546       {
547         if (opt.verbose)
548           log_info(_("`%s' already compressed\n"), filename);
549         do_compress = 0;        
550       }
551     if (rc2)
552       {
553         rc = rc2;
554         goto leave;
555       }
556
557     make_session_key( cfx.dek );
558     if( DBG_CIPHER )
559         log_hexdump("DEK is: ", cfx.dek->key, cfx.dek->keylen );
560
561     rc = write_pubkey_enc_from_list( pk_list, cfx.dek, out );
562     if( rc  )
563         goto leave;
564
565     /* We put the passphrase (if any) after any public keys as this
566        seems to be the most useful on the recipient side - there is no
567        point in prompting a user for a passphrase if they have the
568        secret key needed to decrypt. */
569     if(use_symkey && (rc=write_symkey_enc(symkey_s2k,symkey_dek,cfx.dek,out)))
570       goto leave;
571
572     if (!opt.no_literal) {
573         /* setup the inner packet */
574         if( filename || opt.set_filename ) {
575             char *s = make_basename( opt.set_filename ? opt.set_filename
576                                                       : filename,
577                                      iobuf_get_real_fname( inp ) );
578             pt = xmalloc( sizeof *pt + strlen(s) - 1 );
579             pt->namelen = strlen(s);
580             memcpy(pt->name, s, pt->namelen );
581             xfree(s);
582         }
583         else { /* no filename */
584             pt = xmalloc( sizeof *pt - 1 );
585             pt->namelen = 0;
586         }
587     }
588
589     if (!iobuf_is_pipe_filename (filename) && *filename && !opt.textmode )
590       {
591         off_t tmpsize;
592
593         if ( !(tmpsize = iobuf_get_filelength(inp)) )
594           log_info(_("WARNING: `%s' is an empty file\n"), filename );
595         /* We can't encode the length of very large files because
596            OpenPGP uses only 32 bit for file sizes.  So if the the
597            size of a file is larger than 2^32 minus some bytes for
598            packet headers, we switch to partial length encoding. */
599         if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
600           filesize = tmpsize;
601         else
602           filesize = 0;
603       }
604     else
605       filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
606
607     if (!opt.no_literal) {
608         pt->timestamp = make_timestamp();
609         pt->mode = opt.textmode ? 't' : 'b';
610         pt->len = filesize;
611         pt->new_ctb = !pt->len && !RFC1991;
612         pt->buf = inp;
613         pkt.pkttype = PKT_PLAINTEXT;
614         pkt.pkt.plaintext = pt;
615         cfx.datalen = filesize && !do_compress? calc_packet_length( &pkt ) : 0;
616     }
617     else
618         cfx.datalen = filesize && !do_compress ? filesize : 0;
619
620     /* register the cipher filter */
621     iobuf_push_filter( out, cipher_filter, &cfx );
622
623     /* register the compress filter */
624     if( do_compress ) {
625         int compr_algo = opt.compress_algo;
626
627         if(compr_algo==-1)
628           {
629             if((compr_algo=
630                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
631               compr_algo=DEFAULT_COMPRESS_ALGO;
632             /* Theoretically impossible to get here since uncompressed
633                is implicit. */
634           }
635         else if(!opt.expert &&
636                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
637                                        compr_algo,NULL)!=compr_algo)
638           log_info(_("WARNING: forcing compression algorithm %s (%d)"
639                      " violates recipient preferences\n"),
640                    compress_algo_to_string(compr_algo),compr_algo);
641
642         /* algo 0 means no compression */
643         if( compr_algo )
644           {
645             if (cfx.dek && cfx.dek->use_mdc)
646               zfx.new_ctb = 1;
647             push_compress_filter(out,&zfx,compr_algo);
648           }
649     }
650
651     /* do the work */
652     if (!opt.no_literal) {
653         if( (rc = build_packet( out, &pkt )) )
654             log_error("build_packet failed: %s\n", g10_errstr(rc) );
655     }
656     else {
657         /* user requested not to create a literal packet, so we copy
658            the plain data */
659         byte copy_buffer[4096];
660         int  bytes_copied;
661         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
662             if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
663                 rc = G10ERR_WRITE_FILE;
664                 log_error("copying input to output failed: %s\n",
665                           g10_errstr(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                          cipher_algo_to_string(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_hexdump("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         MPI 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 = pubkey_encrypt( pk->pubkey_algo, enc->data, frame, pk->pkey );
816         mpi_free( frame );
817         if( rc )
818             log_error("pubkey_encrypt failed: %s\n", g10_errstr(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                     pubkey_algo_to_string(enc->pubkey_algo),
824                     cipher_algo_to_string(dek->algo), ustr );
825                 xfree(ustr);
826             }
827             /* and write it */
828             init_packet(&pkt);
829             pkt.pkttype = PKT_PUBKEY_ENC;
830             pkt.pkt.pubkey_enc = enc;
831             rc = build_packet( out, &pkt );
832             if( rc )
833                log_error("build_packet(pubkey_enc) failed: %s\n", g10_errstr(rc));
834         }
835         free_pubkey_enc(enc);
836         if( rc )
837             return rc;
838     }
839     return 0;
840 }
841
842 void
843 encode_crypt_files(int nfiles, char **files, STRLIST remusr)
844 {
845   int rc = 0;
846
847   if (opt.outfile)
848     {
849       log_error(_("--output doesn't work for this command\n"));
850       return;        
851     }
852     
853   if (!nfiles)
854     {
855       char line[2048];
856       unsigned int lno = 0;
857       while ( fgets(line, DIM(line), stdin) )
858         {
859           lno++;
860           if (!*line || line[strlen(line)-1] != '\n')
861             {
862               log_error("input line %u too long or missing LF\n", lno);
863               return;
864             }
865           line[strlen(line)-1] = '\0';
866           print_file_status(STATUS_FILE_START, line, 2);
867           if ( (rc = encode_crypt(line, remusr, 0)) )
868             log_error("encryption of `%s' failed: %s\n",
869                       print_fname_stdin(line), g10_errstr(rc) );
870           write_status( STATUS_FILE_DONE );
871         }
872     }
873   else
874     {
875       while (nfiles--)
876         {
877           print_file_status(STATUS_FILE_START, *files, 2);
878           if ( (rc = encode_crypt(*files, remusr, 0)) )
879             log_error("encryption of `%s' failed: %s\n",
880                       print_fname_stdin(*files), g10_errstr(rc) );
881           write_status( STATUS_FILE_DONE );
882           files++;
883         }
884     }
885 }