gpg: Print a warning on Tor problems.
[gnupg.git] / g10 / encrypt.c
index 518b544..5268946 100644 (file)
@@ -1,6 +1,7 @@
 /* encrypt.c - Main encryption driver
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
  *               2006, 2009 Free Software Foundation, Inc.
+ * Copyright (C) 2016 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
@@ -15,7 +16,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
@@ -23,7 +24,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
-#include <assert.h>
 
 #include "gpg.h"
 #include "options.h"
@@ -65,17 +65,24 @@ encrypt_store (const char *filename)
 }
 
 
-static void
+/* *SESKEY contains the unencrypted session key ((*SESKEY)->KEY) and
+   the algorithm that will be used to encrypt the contents of the SED
+   packet ((*SESKEY)->ALGO).  If *SESKEY is NULL, then a random
+   session key that is appropriate for DEK->ALGO is generated and
+   stored there.
+
+   Encrypt that session key using DEK and store the result in ENCKEY,
+   which must be large enough to hold (*SESKEY)->KEYLEN + 1 bytes.  */
+void
 encrypt_seskey (DEK *dek, DEK **seskey, byte *enckey)
 {
   gcry_cipher_hd_t hd;
   byte buf[33];
 
-  assert ( dek->keylen <= 32 );
+  log_assert ( dek->keylen <= 32 );
   if (!*seskey)
     {
       *seskey=xmalloc_clear(sizeof(DEK));
-      (*seskey)->keylen=dek->keylen;
       (*seskey)->algo=dek->algo;
       make_session_key(*seskey);
       /*log_hexdump( "thekey", c->key, c->keylen );*/
@@ -85,7 +92,7 @@ encrypt_seskey (DEK *dek, DEK **seskey, byte *enckey)
   buf[0] = (*seskey)->algo;
   memcpy( buf + 1, (*seskey)->key, (*seskey)->keylen );
 
-  /* We only pass already checked values to the following fucntion,
+  /* We only pass already checked values to the following function,
      thus we consider any failure as fatal.  */
   if (openpgp_cipher_open (&hd, dek->algo, GCRY_CIPHER_MODE_CFB, 1))
     BUG ();
@@ -101,8 +108,8 @@ encrypt_seskey (DEK *dek, DEK **seskey, byte *enckey)
 
 
 /* We try very hard to use a MDC */
-static int
-use_mdc(PK_LIST pk_list,int algo)
+int
+use_mdc (pk_list_t pk_list,int algo)
 {
   /* RFC-2440 don't has MDC */
   if (RFC2440)
@@ -214,8 +221,7 @@ encrypt_simple (const char *filename, int mode, int use_seskey)
       s2k = xmalloc_clear( sizeof *s2k );
       s2k->mode = opt.s2k_mode;
       s2k->hash_algo = S2K_DIGEST_ALGO;
-      cfx.dek = passphrase_to_dek (NULL, 0,
-                                   default_cipher_algo(), s2k, 4,
+      cfx.dek = passphrase_to_dek (default_cipher_algo (), s2k, 1, 0,
                                    NULL, &canceled);
       if ( !cfx.dek || !cfx.dek->keylen )
         {
@@ -287,7 +293,7 @@ encrypt_simple (const char *filename, int mode, int use_seskey)
       pkt.pkttype = PKT_SYMKEY_ENC;
       pkt.pkt.symkey_enc = enc;
       if ((rc = build_packet( out, &pkt )))
-        log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
+        log_error("build symkey packet failed: %s\n", gpg_strerror (rc) );
       xfree (enc);
     }
 
@@ -326,8 +332,9 @@ encrypt_simple (const char *filename, int mode, int use_seskey)
 
   if (!opt.no_literal)
     {
+      /* Note that PT has been initialized above in !no_literal mode.  */
       pt->timestamp = make_timestamp();
-      pt->mode = opt.textmode? 't' : 'b';
+      pt->mode = opt.mimemode? 'm' : opt.textmode? 't' : 'b';
       pt->len = filesize;
       pt->new_ctb = !pt->len;
       pt->buf = inp;
@@ -358,7 +365,7 @@ encrypt_simple (const char *filename, int mode, int use_seskey)
   if (!opt.no_literal)
     {
       if ( (rc = build_packet( out, &pkt )) )
-        log_error("build_packet failed: %s\n", g10_errstr(rc) );
+        log_error("build_packet failed: %s\n", gpg_strerror (rc) );
     }
   else
     {
@@ -405,8 +412,8 @@ setup_symkey (STRING2KEY **symkey_s2k,DEK **symkey_dek)
   (*symkey_s2k)->mode = opt.s2k_mode;
   (*symkey_s2k)->hash_algo = S2K_DIGEST_ALGO;
 
-  *symkey_dek=passphrase_to_dek(NULL,0,opt.s2k_cipher_algo,
-                               *symkey_s2k, 4, NULL, &canceled);
+  *symkey_dek = passphrase_to_dek (opt.s2k_cipher_algo,
+                                   *symkey_s2k, 1, 0, NULL, &canceled);
   if(!*symkey_dek || !(*symkey_dek)->keylen)
     {
       xfree(*symkey_dek);
@@ -441,7 +448,7 @@ write_symkey_enc (STRING2KEY *symkey_s2k, DEK *symkey_dek, DEK *dek,
   pkt.pkt.symkey_enc = enc;
 
   if ((rc=build_packet(out,&pkt)))
-    log_error("build symkey_enc packet failed: %s\n",g10_errstr(rc));
+    log_error("build symkey_enc packet failed: %s\n",gpg_strerror (rc));
 
   xfree(enc);
   return rc;
@@ -453,6 +460,9 @@ write_symkey_enc (STRING2KEY *symkey_s2k, DEK *symkey_dek, DEK *dek,
  * supplied).  Either FILENAME or FILEFD must be given, but not both.
  * The caller may provide a checked list of public keys in
  * PROVIDED_PKS; if not the function builds a list of keys on its own.
+ *
+ * Note that FILEFD is currently only used by cmd_encrypt in the the
+ * not yet finished server.c.
  */
 int
 encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
@@ -476,7 +486,7 @@ encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
   int do_compress;
 
   if (filefd != -1 && filename)
-    return gpg_error (GPG_ERR_INV_ARG);
+    return gpg_error (GPG_ERR_INV_ARG);  /* Both given.  */
 
   do_compress = !!opt.compress_algo;
 
@@ -497,7 +507,7 @@ encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
     pk_list = provided_keys;
   else
     {
-      if ((rc = build_pk_list (ctrl, remusr, &pk_list, PUBKEY_USAGE_ENC)))
+      if ((rc = build_pk_list (ctrl, remusr, &pk_list)))
         {
           release_progress_context (pfx);
           return rc;
@@ -507,14 +517,17 @@ encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
   /* Prepare iobufs. */
 #ifdef HAVE_W32_SYSTEM
   if (filefd == -1)
-    inp = iobuf_open_fd_or_name (GNUPG_INVALID_FD, filename, "rb");
+    inp = iobuf_open (filename);
   else
     {
       inp = NULL;
       gpg_err_set_errno (ENOSYS);
     }
 #else
-  inp = iobuf_open_fd_or_name (filefd, filename, "rb");
+  if (filefd == GNUPG_INVALID_FD)
+    inp = iobuf_open (filename);
+  else
+    inp = iobuf_fdopen_nc (FD2INT(filefd), "rb");
 #endif
   if (inp)
     iobuf_ioctl (inp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
@@ -618,7 +631,7 @@ encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
     }
 
   make_session_key (cfx.dek);
-  if (DBG_CIPHER)
+  if (DBG_CRYPTO)
     log_printhex ("DEK is: ", cfx.dek->key, cfx.dek->keylen );
 
   rc = write_pubkey_enc_from_list (pk_list, cfx.dek, out);
@@ -635,8 +648,9 @@ encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
   if (!opt.no_literal)
     pt = setup_plaintext_name (filename, inp);
 
-  if (filefd != -1
-      && !iobuf_is_pipe_filename (filename) && *filename && !opt.textmode )
+  /* Get the size of the file if possible, i.e., if it is a real file.  */
+  if (filename && *filename
+      && !iobuf_is_pipe_filename (filename) && !opt.textmode )
     {
       off_t tmpsize;
       int overflow;
@@ -659,7 +673,7 @@ encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
   if (!opt.no_literal)
     {
       pt->timestamp = make_timestamp();
-      pt->mode = opt.textmode ? 't' : 'b';
+      pt->mode = opt.mimemode? 'm' : opt.textmode ? 't' : 'b';
       pt->len = filesize;
       pt->new_ctb = !pt->len;
       pt->buf = inp;
@@ -708,7 +722,7 @@ encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
   if (!opt.no_literal)
     {
       if ((rc = build_packet( out, &pkt )))
-        log_error ("build_packet failed: %s\n", g10_errstr(rc));
+        log_error ("build_packet failed: %s\n", gpg_strerror (rc));
     }
   else
     {
@@ -811,25 +825,25 @@ encrypt_filter (void *opaque, int control,
           efx->cfx.dek->use_mdc = use_mdc (efx->pk_list,efx->cfx.dek->algo);
 
           make_session_key ( efx->cfx.dek );
-          if (DBG_CIPHER)
+          if (DBG_CRYPTO)
             log_printhex ("DEK is: ", efx->cfx.dek->key, efx->cfx.dek->keylen);
 
           rc = write_pubkey_enc_from_list (efx->pk_list, efx->cfx.dek, a);
           if (rc)
             return rc;
 
-           if(efx->symkey_s2k && efx->symkey_dek)
-             {
-               rc=write_symkey_enc(efx->symkey_s2k,efx->symkey_dek,
-                                   efx->cfx.dek,a);
-               if(rc)
-                 return rc;
-             }
+          if(efx->symkey_s2k && efx->symkey_dek)
+            {
+              rc=write_symkey_enc(efx->symkey_s2k,efx->symkey_dek,
+                                  efx->cfx.dek,a);
+              if(rc)
+                return rc;
+            }
 
-           iobuf_push_filter (a, cipher_filter, &efx->cfx);
+          iobuf_push_filter (a, cipher_filter, &efx->cfx);
 
-           efx->header_okay = 1;
-       }
+          efx->header_okay = 1;
+        }
       rc = iobuf_write (a, buf, size);
 
     }
@@ -840,88 +854,97 @@ encrypt_filter (void *opaque, int control,
     }
   else if ( control == IOBUFCTRL_DESC )
     {
-      *(char**)buf = "encrypt_filter";
+      mem2str (buf, "encrypt_filter", *ret_len);
     }
   return rc;
 }
 
 
 /*
- * Write pubkey-enc packets from the list of PKs to OUT.
+ * Write a pubkey-enc packet for the public key PK to OUT.
  */
-static int
-write_pubkey_enc_from_list (PK_LIST pk_list, DEK *dek, iobuf_t out)
+int
+write_pubkey_enc (PKT_public_key *pk, int throw_keyid, DEK *dek, iobuf_t out)
 {
   PACKET pkt;
-  PKT_public_key *pk;
-  PKT_pubkey_enc  *enc;
+  PKT_pubkey_enc *enc;
   int rc;
-
-  for ( ; pk_list; pk_list = pk_list->next )
+  gcry_mpi_t frame;
+
+  print_pubkey_algo_note ( pk->pubkey_algo );
+  enc = xmalloc_clear ( sizeof *enc );
+  enc->pubkey_algo = pk->pubkey_algo;
+  keyid_from_pk( pk, enc->keyid );
+  enc->throw_keyid = throw_keyid;
+
+  /* Okay, what's going on: We have the session key somewhere in
+   * the structure DEK and want to encode this session key in an
+   * integer value of n bits. pubkey_nbits gives us the number of
+   * bits we have to use.  We then encode the session key in some
+   * way and we get it back in the big intger value FRAME.  Then
+   * we use FRAME, the public key PK->PKEY and the algorithm
+   * number PK->PUBKEY_ALGO and pass it to pubkey_encrypt which
+   * returns the encrypted value in the array ENC->DATA.  This
+   * array has a size which depends on the used algorithm (e.g. 2
+   * for Elgamal).  We don't need frame anymore because we have
+   * everything now in enc->data which is the passed to
+   * build_packet().  */
+  frame = encode_session_key (pk->pubkey_algo, dek,
+                              pubkey_nbits (pk->pubkey_algo, pk->pkey));
+  rc = pk_encrypt (pk->pubkey_algo, enc->data, frame, pk, pk->pkey);
+  gcry_mpi_release (frame);
+  if (rc)
+    log_error ("pubkey_encrypt failed: %s\n", gpg_strerror (rc) );
+  else
     {
-      gcry_mpi_t frame;
-
-      pk = pk_list->pk;
-
-      print_pubkey_algo_note ( pk->pubkey_algo );
-      enc = xmalloc_clear ( sizeof *enc );
-      enc->pubkey_algo = pk->pubkey_algo;
-      keyid_from_pk( pk, enc->keyid );
-      enc->throw_keyid = (opt.throw_keyid || (pk_list->flags&1));
-
-      if (opt.throw_keyid && (PGP6 || PGP7 || PGP8))
+      if ( opt.verbose )
         {
-          log_info(_("you may not use %s while in %s mode\n"),
-                   "--throw-keyids",compliance_option_string());
-          compliance_failure();
+          char *ustr = get_user_id_string_native (enc->keyid);
+          log_info (_("%s/%s encrypted for: \"%s\"\n"),
+                    openpgp_pk_algo_name (enc->pubkey_algo),
+                    openpgp_cipher_algo_name (dek->algo),
+                    ustr );
+          xfree (ustr);
         }
-
-      /* Okay, what's going on: We have the session key somewhere in
-       * the structure DEK and want to encode this session key in an
-       * integer value of n bits. pubkey_nbits gives us the number of
-       * bits we have to use.  We then encode the session key in some
-       * way and we get it back in the big intger value FRAME.  Then
-       * we use FRAME, the public key PK->PKEY and the algorithm
-       * number PK->PUBKEY_ALGO and pass it to pubkey_encrypt which
-       * returns the encrypted value in the array ENC->DATA.  This
-       * array has a size which depends on the used algorithm (e.g. 2
-       * for Elgamal).  We don't need frame anymore because we have
-       * everything now in enc->data which is the passed to
-       * build_packet().  */
-      frame = encode_session_key (pk->pubkey_algo, dek,
-                                  pubkey_nbits (pk->pubkey_algo, pk->pkey));
-      rc = pk_encrypt (pk->pubkey_algo, enc->data, frame, pk, pk->pkey);
-      gcry_mpi_release (frame);
+      /* And write it. */
+      init_packet (&pkt);
+      pkt.pkttype = PKT_PUBKEY_ENC;
+      pkt.pkt.pubkey_enc = enc;
+      rc = build_packet (out, &pkt);
       if (rc)
-        log_error ("pubkey_encrypt failed: %s\n", gpg_strerror (rc) );
-      else
-        {
-          if ( opt.verbose )
-            {
-              char *ustr = get_user_id_string_native (enc->keyid);
-              log_info (_("%s/%s encrypted for: \"%s\"\n"),
-                        openpgp_pk_algo_name (enc->pubkey_algo),
-                        openpgp_cipher_algo_name (dek->algo),
-                        ustr );
-              xfree (ustr);
-           }
-          /* And write it. */
-          init_packet (&pkt);
-          pkt.pkttype = PKT_PUBKEY_ENC;
-          pkt.pkt.pubkey_enc = enc;
-          rc = build_packet (out, &pkt);
-          if (rc)
-            log_error ("build_packet(pubkey_enc) failed: %s\n",
-                       g10_errstr (rc));
-       }
-      free_pubkey_enc(enc);
+        log_error ("build_packet(pubkey_enc) failed: %s\n",
+                   gpg_strerror (rc));
+    }
+  free_pubkey_enc(enc);
+  return rc;
+}
+
+
+/*
+ * Write pubkey-enc packets from the list of PKs to OUT.
+ */
+static int
+write_pubkey_enc_from_list (PK_LIST pk_list, DEK *dek, iobuf_t out)
+{
+  if (opt.throw_keyids && (PGP6 || PGP7 || PGP8))
+    {
+      log_info(_("you may not use %s while in %s mode\n"),
+               "--throw-keyids",compliance_option_string());
+      compliance_failure();
+    }
+
+  for ( ; pk_list; pk_list = pk_list->next )
+    {
+      PKT_public_key *pk = pk_list->pk;
+      int throw_keyid = (opt.throw_keyids || (pk_list->flags&1));
+      int rc = write_pubkey_enc (pk, throw_keyid, dek, out);
       if (rc)
         return rc;
     }
+
   return 0;
 }
 
-
 void
 encrypt_crypt_files (ctrl_t ctrl, int nfiles, char **files, strlist_t remusr)
 {
@@ -950,7 +973,7 @@ encrypt_crypt_files (ctrl_t ctrl, int nfiles, char **files, strlist_t remusr)
           rc = encrypt_crypt (ctrl, -1, line, remusr, 0, NULL, -1);
           if (rc)
             log_error ("encryption of '%s' failed: %s\n",
-                       print_fname_stdin(line), g10_errstr(rc) );
+                       print_fname_stdin(line), gpg_strerror (rc) );
           write_status( STATUS_FILE_DONE );
         }
     }
@@ -961,7 +984,7 @@ encrypt_crypt_files (ctrl_t ctrl, int nfiles, char **files, strlist_t remusr)
           print_file_status(STATUS_FILE_START, *files, 2);
           if ( (rc = encrypt_crypt (ctrl, -1, *files, remusr, 0, NULL, -1)) )
             log_error("encryption of '%s' failed: %s\n",
-                      print_fname_stdin(*files), g10_errstr(rc) );
+                      print_fname_stdin(*files), gpg_strerror (rc) );
           write_status( STATUS_FILE_DONE );
           files++;
         }