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