The keybox gets now compressed after 3 hours and ephemeral
[gnupg.git] / sm / encrypt.c
index 7037f27..8cc9a88 100644 (file)
@@ -1,5 +1,5 @@
 /* encrypt.c - Encrypt a message
- *     Copyright (C) 2001 Free Software Foundation, Inc.
+ *     Copyright (C) 2001, 2003, 2004 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <time.h>
 #include <assert.h>
 
+#include "gpgsm.h"
 #include <gcrypt.h>
 #include <ksba.h>
 
-#include "gpgsm.h"
 #include "keydb.h"
 #include "i18n.h"
 
@@ -38,7 +38,7 @@
 struct dek_s {
   const char *algoid;
   int algo;
-  GCRY_CIPHER_HD chd;
+  gcry_cipher_hd_t chd;
   char key[32];
   int keylen;
   char iv[32];
@@ -58,49 +58,10 @@ struct encrypt_cb_parm_s {
 };
 
 
-static KsbaCert
-get_default_recipient (void)
-{
-  const char key[] =
-    "CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=Düsseldorf,C=DE";
-
-  KEYDB_SEARCH_DESC desc;
-  KsbaCert cert = NULL;
-  KEYDB_HANDLE kh = NULL;
-  int rc;
-
-  rc = keydb_classify_name (key, &desc);
-  if (rc)
-    {
-      log_error ("failed to find recipient: %s\n", gnupg_strerror (rc));
-      return NULL;
-    }
-
-  kh = keydb_new (0);
-  if (!kh)
-    return NULL;
-
-  rc = keydb_search (kh, &desc, 1);
-  if (rc)
-    {
-      log_debug ("failed to find default certificate: rc=%d\n", rc);
-    }
-  else 
-    {
-      rc = keydb_get_cert (kh, &cert);
-      if (rc)
-        {
-          log_debug ("failed to get cert: rc=%d\n", rc);
-        }
-    }
-
-  keydb_release (kh);
-  return cert;
-}
 
 
 \f
-/* initialize the data encryptionkey (session key) */
+/* Initialize the data encryption key (session key). */
 static int
 init_dek (DEK dek)
 {
@@ -111,143 +72,106 @@ init_dek (DEK dek)
   if (!dek->algo || !mode)
     {
       log_error ("unsupported algorithm `%s'\n", dek->algoid);
-      return GNUPG_Unsupported_Algorithm;
+      return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
+    }
+  
+  /* Extra check for algorithms we considere to be to weak for
+     encryption, qlthough we suppor them fro decryption.  Note that
+     there is another check below discriminating on the key length. */
+  switch (dek->algo)
+    {
+    case GCRY_CIPHER_DES:
+    case GCRY_CIPHER_RFC2268_40:
+      log_error ("cipher algorithm `%s' not allowed: too weak\n",
+                 gcry_cipher_algo_name (dek->algo));
+      return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
+    default:
+      break;
     }
 
   dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
   if (!dek->keylen || dek->keylen > sizeof (dek->key))
-    return GNUPG_Bug;
+    return gpg_error (GPG_ERR_BUG);
 
   dek->ivlen = gcry_cipher_get_algo_blklen (dek->algo);
   if (!dek->ivlen || dek->ivlen > sizeof (dek->iv))
-    return GNUPG_Bug;
+    return gpg_error (GPG_ERR_BUG);
 
+  /* Make sure we don't use weak keys. */
   if (dek->keylen < 100/8)
-    { /* make sure we don't use weak keys */
+    { 
       log_error ("key length of `%s' too small\n", dek->algoid);
-      return GNUPG_Unsupported_Algorithm;
+      return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
     }
   
-  dek->chd = gcry_cipher_open (dek->algo, mode, GCRY_CIPHER_SECURE);
-  if (!dek->chd)
+  rc = gcry_cipher_open (&dek->chd, dek->algo, mode, GCRY_CIPHER_SECURE);
+  if (rc)
     {
-      log_error ("failed to create cipher context: %s\n", gcry_strerror (-1));
-      return GNUPG_General_Error;
+      log_error ("failed to create cipher context: %s\n", gpg_strerror (rc));
+      return rc;
     }
   
   for (i=0; i < 8; i++)
     {
       gcry_randomize (dek->key, dek->keylen, GCRY_STRONG_RANDOM );
       rc = gcry_cipher_setkey (dek->chd, dek->key, dek->keylen);
-      if (rc != GCRYERR_WEAK_KEY)
+      if (gpg_err_code (rc) != GPG_ERR_WEAK_KEY)
         break;
       log_info(_("weak key created - retrying\n") );
     }
   if (rc)
     {
-      log_error ("failed to set the key: %s\n", gcry_strerror (rc));
+      log_error ("failed to set the key: %s\n", gpg_strerror (rc));
       gcry_cipher_close (dek->chd);
       dek->chd = NULL;
-      return map_gcry_err (rc);
+      return rc;
     }
 
-  gcry_randomize (dek->iv, dek->ivlen, GCRY_STRONG_RANDOM);
+  gcry_create_nonce (dek->iv, dek->ivlen);
   rc = gcry_cipher_setiv (dek->chd, dek->iv, dek->ivlen);
   if (rc)
     {
-      log_error ("failed to set the IV: %s\n", gcry_strerror (rc));
+      log_error ("failed to set the IV: %s\n", gpg_strerror (rc));
       gcry_cipher_close (dek->chd);
       dek->chd = NULL;
-      return map_gcry_err (rc);
+      return rc;
     }
   
   return 0;
 }
 
 
-/* Encode the session key. NBITS is the number of bits which should be
-   used for packing the session key.  returns: An mpi with the session
-   key (caller must free) */
-static GCRY_MPI
-encode_session_key (DEK dek, unsigned int nbits)
+static int
+encode_session_key (DEK dek, gcry_sexp_t * r_data)
 {
-  int nframe = (nbits+7) / 8;
-  byte *p;
-  byte *frame;
-  int i,n;
-  MPI a;
-
-  if (dek->keylen + 7 > nframe || !nframe)
-    log_bug ("can't encode a %d bit key in a %d bits frame\n",
-             dek->keylen*8, nbits );
-
-  /* We encode the session key in this way:
-   *
-   *      0  2  RND(n bytes)  0  KEY(k bytes)
-   *
-   * (But how can we store the leading 0 - the external representaion
-   *   of MPIs doesn't allow leading zeroes =:-)
-   *
-   * RND are non-zero random bytes.
-   * KEY is the encryption key (session key) 
-   */
-
-  frame = gcry_xmalloc_secure (nframe);
-  n = 0;
-  frame[n++] = 0;
-  frame[n++] = 2;
-  i = nframe - 3 - dek->keylen;
-  assert (i > 0);
-  p = gcry_random_bytes_secure (i, GCRY_STRONG_RANDOM);
-  /* replace zero bytes by new values */
-  for (;;)
-    {
-      int j, k;
-      byte *pp;
-
-      /* count the zero bytes */
-      for(j=k=0; j < i; j++ )
-        {
-          if( !p[j] )
-            k++;
-        }
-      if( !k )
-        break; /* okay: no zero bytes */
+  gcry_sexp_t data;
+  char * p, tmp[3];
+  int i;
+  int rc;
 
-      k += k/128; /* better get some more */
-      pp = gcry_random_bytes_secure (k, GCRY_STRONG_RANDOM);
-      for (j=0; j < i && k; j++)
-        {
-          if( !p[j] )
-            p[j] = pp[--k];
-        }
-      xfree (pp);
+  p = xmalloc (64 + 2 * dek->keylen);
+  strcpy (p, "(data\n (flags pkcs1)\n (value #");
+  for (i=0; i < dek->keylen; i++)
+    {
+      sprintf (tmp, "%02x", (unsigned char) dek->key[i]);
+      strcat (p, tmp);   
     }
-  memcpy (frame+n, p, i);
+  strcat (p, "#))\n");
+  rc = gcry_sexp_sscan (&data, NULL, p, strlen (p));
   xfree (p);
-
-  n += i;
-  frame[n++] = 0;
-  memcpy (frame+n, dek->key, dek->keylen);
-  n += dek->keylen;
-  assert (n == nframe);
-  if (gcry_mpi_scan (&a, GCRYMPI_FMT_USG, frame, &nframe) )
-    BUG ();
-  gcry_free(frame);
-
-  return a;
+  *r_data = data;
+  return rc;    
 }
 
 
-
 /* encrypt the DEK under the key contained in CERT and return it as a
    canonical S-Exp in encval */
 static int
-encrypt_dek (const DEK dek, KsbaCert cert, char **encval)
+encrypt_dek (const DEK dek, ksba_cert_t cert, char **encval)
 {
-  GCRY_SEXP s_ciph, s_data, s_pkey;
+  gcry_sexp_t s_ciph, s_data, s_pkey;
   int rc;
-  char *buf;
+  ksba_sexp_t buf;
   size_t len;
 
   *encval = NULL;
@@ -257,28 +181,28 @@ encrypt_dek (const DEK dek, KsbaCert cert, char **encval)
   if (!buf)
     {
       log_error ("no public key for recipient\n");
-      return GNUPG_No_Public_Key;
+      return gpg_error (GPG_ERR_NO_PUBKEY);
     }
-  rc = gcry_sexp_sscan (&s_pkey, NULL, buf, strlen(buf));
+  len = gcry_sexp_canon_len (buf, 0, NULL, NULL);
+  if (!len)
+    {
+      log_error ("libksba did not return a proper S-Exp\n");
+      return gpg_error (GPG_ERR_BUG);
+    }
+  rc = gcry_sexp_sscan (&s_pkey, NULL, buf, len);
   xfree (buf); buf = NULL;
   if (rc)
     {
-      log_error ("gcry_sexp_scan failed: %s\n", gcry_strerror (rc));
-      return map_gcry_err (rc);
+      log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
+      return rc;
     }
 
   /* put the encoded cleartext into a simple list */
+  rc = encode_session_key (dek, &s_data);
+  if (rc)
   {
-    /* fixme: actually the pkcs-1 encoding should go into libgcrypt */
-    GCRY_MPI data = encode_session_key (dek, gcry_pk_get_nbits (s_pkey));
-    if (!data)
-      {
-        gcry_mpi_release (data);
-        return GNUPG_General_Error;
-      }
-    if (gcry_sexp_build (&s_data, NULL, "%m", data))
-      BUG ();
-    gcry_mpi_release (data);
+    log_error ("encode_session_key failed: %s\n", gpg_strerror (rc));
+    return rc;
   }
 
   /* pass it to libgcrypt */
@@ -292,8 +216,9 @@ encrypt_dek (const DEK dek, KsbaCert cert, char **encval)
   buf = xtrymalloc (len);
   if (!buf)
     {
+      gpg_error_t tmperr = OUT_OF_CORE (errno);
       gcry_sexp_release (s_ciph);
-      return GNUPG_Out_Of_Core;
+      return tmperr;
     }
   len = gcry_sexp_sprint (s_ciph, GCRYSEXP_FMT_CANON, buf, len);
   assert (len);
@@ -382,74 +307,72 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
 {
   int rc = 0;
   Base64Context b64writer = NULL;
-  KsbaError err;
-  KsbaWriter writer;
-  KsbaReader reader = NULL;
-  KsbaCMS cms = NULL;
-  KsbaStopReason stopreason;
+  gpg_error_t err;
+  ksba_writer_t writer;
+  ksba_reader_t reader = NULL;
+  ksba_cms_t cms = NULL;
+  ksba_stop_reason_t stopreason;
   KEYDB_HANDLE kh = NULL;
   struct encrypt_cb_parm_s encparm;
   DEK dek = NULL;
   int recpno;
   FILE *data_fp = NULL;
-  struct certlist_s help_recplist;
   CERTLIST cl;
 
   memset (&encparm, 0, sizeof encparm);
-  help_recplist.next = NULL;
-  help_recplist.cert = NULL;
-  kh = keydb_new (0);
-  if (!kh)
+
+  /* Check that the certificate list is not empty and that at least
+     one certificate is not flagged as encrypt_to; i.e. is a real
+     recipient. */
+  for (cl = recplist; cl; cl = cl->next)
+    if (!cl->is_encrypt_to)
+      break;
+  if (!cl)
     {
-      log_error (_("failed to allocated keyDB handle\n"));
-      rc = GNUPG_General_Error;
+      log_error(_("no valid recipients given\n"));
+      gpgsm_status (ctrl, STATUS_NO_RECP, "0");
+      rc = gpg_error (GPG_ERR_NO_PUBKEY);
       goto leave;
     }
 
-  /* If no recipient list is given, use a default one */
-  if (!recplist)
+  kh = keydb_new (0);
+  if (!kh)
     {
-      help_recplist.cert = get_default_recipient ();
-      if (!help_recplist.cert)
-        {
-          log_error ("no default recipient found\n");
-          rc = seterr (General_Error);
-          goto leave;
-        }
-      recplist = &help_recplist;
+      log_error (_("failed to allocated keyDB handle\n"));
+      rc = gpg_error (GPG_ERR_GENERAL);
+      goto leave;
     }
 
   data_fp = fdopen ( dup (data_fd), "rb");
   if (!data_fp)
     {
+      rc = gpg_error (gpg_err_code_from_errno (errno));
       log_error ("fdopen() failed: %s\n", strerror (errno));
-      rc = seterr (IO_Error);
       goto leave;
     }
 
-  reader = ksba_reader_new ();
-  if (!reader)
-      rc = KSBA_Out_Of_Core;
+  err = ksba_reader_new (&reader);
+  if (err)
+      rc = err;
   if (!rc)
     rc = ksba_reader_set_cb (reader, encrypt_cb, &encparm);
   if (rc)
-    {
-      rc = map_ksba_err (rc);
       goto leave;
-    }
+
   encparm.fp = data_fp;
 
+  ctrl->pem_name = "ENCRYPTED MESSAGE";
   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
   if (rc)
     {
-      log_error ("can't create writer: %s\n", gnupg_strerror (rc));
+      log_error ("can't create writer: %s\n", gpg_strerror (rc));
       goto leave;
     }
 
-  cms = ksba_cms_new ();
-  if (!cms)
+  err = ksba_cms_new (&cms);
+  if (err)
     {
-      rc = seterr (Out_Of_Core);
+      rc = err;
       goto leave;
     }
 
@@ -457,8 +380,8 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   if (err)
     {
       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
-                 ksba_strerror (err));
-      rc = map_ksba_err (err);
+                 gpg_strerror (err));
+      rc = err;
       goto leave;
     }
 
@@ -470,15 +393,15 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   if (err)
     {
       log_debug ("ksba_cms_set_content_type failed: %s\n",
-                 ksba_strerror (err));
-      rc = map_ksba_err (err);
+                 gpg_strerror (err));
+      rc = err;
       goto leave;
     }
 
   /* create a session key */
   dek = xtrycalloc (1, sizeof *dek); /* hmmm: should we put it into secmem?*/
   if (!dek)
-    rc = GNUPG_Out_Of_Core;
+    rc = OUT_OF_CORE (errno);
   else
   {
     dek->algoid = opt.def_cipher_algoid;
@@ -487,7 +410,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   if (rc)
     {
       log_error ("failed to create the session key: %s\n",
-                 gnupg_strerror (rc));
+                 gpg_strerror (rc));
       goto leave;
     }
 
@@ -495,23 +418,22 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   if (err)
     {
       log_error ("ksba_cms_set_content_enc_algo failed: %s\n",
-                 ksba_strerror (err));
-      rc = map_ksba_err (err);
+                 gpg_strerror (err));
+      rc = err;
       goto leave;
     }
 
   encparm.dek = dek;
-  /* fixme: we should use a larger buffer - the small one is better
-     for testing */
-  encparm.bufsize = 10 * dek->ivlen;
+  /* Use a ~8k (AES) or ~4k (3DES) buffer */
+  encparm.bufsize = 500 * dek->ivlen;
   encparm.buffer = xtrymalloc (encparm.bufsize);
   if (!encparm.buffer)
     {
-      rc = seterr (Out_Of_Core);
+      rc = OUT_OF_CORE (errno);
       goto leave;
     }
 
-  /* gather certificates of recipients, encrypt the session key for
+  /* Gather certificates of recipients, encrypt the session key for
      each and store them in the CMS object */
   for (recpno = 0, cl = recplist; cl; recpno++, cl = cl->next)
     {
@@ -521,7 +443,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
       if (rc)
         {
           log_error ("encryption failed for recipient no. %d: %s\n",
-                     recpno, gnupg_strerror (rc));
+                     recpno, gpg_strerror (rc));
           goto leave;
         }
       
@@ -529,8 +451,8 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
       if (err)
         {
           log_error ("ksba_cms_add_recipient failed: %s\n",
-                     ksba_strerror (err));
-          rc = map_ksba_err (err);
+                     gpg_strerror (err));
+          rc = err;
           xfree (encval);
           goto leave;
         }
@@ -540,21 +462,21 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
       if (err)
         {
           log_error ("ksba_cms_set_enc_val failed: %s\n",
-                     ksba_strerror (err));
-          rc = map_ksba_err (err);
+                     gpg_strerror (err));
+          rc = err;
           goto leave;
         }
   }
 
-  /* main control loop for encryption */
+  /* Main control loop for encryption. */
   recpno = 0;
   do 
     {
       err = ksba_cms_build (cms, &stopreason);
       if (err)
         {
-          log_debug ("ksba_cms_build failed: %s\n", ksba_strerror (err));
-          rc = map_ksba_err (err);
+          log_debug ("ksba_cms_build failed: %s\n", gpg_strerror (err));
+          rc = err;
           goto leave;
         }
     }
@@ -563,7 +485,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   if (encparm.readerror)
     {
       log_error ("error reading input: %s\n", strerror (encparm.readerror));
-      rc = seterr (Read_Error);
+      rc = gpg_error (gpg_err_code_from_errno (encparm.readerror));
       goto leave;
     }
 
@@ -571,7 +493,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   rc = gpgsm_finish_writer (b64writer);
   if (rc) 
     {
-      log_error ("write failed: %s\n", gnupg_strerror (rc));
+      log_error ("write failed: %s\n", gpg_strerror (rc));
       goto leave;
     }
   log_info ("encrypted data created\n");
@@ -585,7 +507,5 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   if (data_fp)
     fclose (data_fp);
   xfree (encparm.buffer);
-  if (help_recplist.cert)
-    ksba_cert_release (help_recplist.cert);
   return rc;
 }