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