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