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