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