g10/encrypt.c

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