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