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