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