sm: In --gen-key with "key from card" show also the algorithm.
[gnupg.git] / sm / encrypt.c
index 8f2c26b..6213a66 100644 (file)
@@ -1,11 +1,12 @@
 /* encrypt.c - Encrypt a message
- *     Copyright (C) 2001, 2003 Free Software Foundation, Inc.
+ * Copyright (C) 2001, 2003, 2004, 2007, 2008,
+ *               2010 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
@@ -14,8 +15,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, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
@@ -23,7 +23,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
-#include <unistd.h> 
+#include <unistd.h>
 #include <time.h>
 #include <assert.h>
 
@@ -32,7 +32,8 @@
 #include <ksba.h>
 
 #include "keydb.h"
-#include "i18n.h"
+#include "../common/i18n.h"
+#include "../common/compliance.h"
 
 
 struct dek_s {
@@ -46,8 +47,11 @@ struct dek_s {
 };
 typedef struct dek_s *DEK;
 
-struct encrypt_cb_parm_s {
-  FILE *fp;
+
+/* Callback parameters for the encryption.  */
+struct encrypt_cb_parm_s
+{
+  estream_t fp;
   DEK dek;
   int eof_seen;
   int ready;
@@ -71,10 +75,24 @@ init_dek (DEK dek)
   mode = gcry_cipher_mode_from_oid (dek->algoid);
   if (!dek->algo || !mode)
     {
-      log_error ("unsupported algorithm `%s'\n", dek->algoid);
+      log_error ("unsupported algorithm '%s'\n", dek->algoid);
       return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
     }
 
+  /* Extra check for algorithms we consider to be too weak for
+     encryption, although we support them for 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",
+                 gnupg_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 gpg_error (GPG_ERR_BUG);
@@ -83,19 +101,20 @@ init_dek (DEK dek)
   if (!dek->ivlen || dek->ivlen > sizeof (dek->iv))
     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);
+    {
+      log_error ("key length of '%s' too small\n", dek->algoid);
       return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
     }
-  
+
   rc = gcry_cipher_open (&dek->chd, dek->algo, mode, GCRY_CIPHER_SECURE);
   if (rc)
     {
       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 );
@@ -121,7 +140,7 @@ init_dek (DEK dek)
       dek->chd = NULL;
       return rc;
     }
-  
+
   return 0;
 }
 
@@ -130,29 +149,26 @@ static int
 encode_session_key (DEK dek, gcry_sexp_t * r_data)
 {
   gcry_sexp_t data;
-  char * p, tmp[3];
-  int i;
+  char *p;
   int rc;
 
-  p = xmalloc (64 + 2 * dek->keylen);
+  p = xtrymalloc (64 + 2 * dek->keylen);
+  if (!p)
+    return gpg_error_from_syserror ();
   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);   
-    }
+  bin2hex (dek->key, dek->keylen, p + strlen (p));
   strcat (p, "#))\n");
   rc = gcry_sexp_sscan (&data, NULL, p, strlen (p));
   xfree (p);
   *r_data = data;
-  return rc;    
+  return rc;
 }
 
 
-/* encrypt the DEK under the key contained in CERT and return it as a
-   canonical S-Exp in encval */
+/* 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, ksba_cert_t cert, char **encval)
+encrypt_dek (const DEK dek, ksba_cert_t cert, unsigned char **encval)
 {
   gcry_sexp_t s_ciph, s_data, s_pkey;
   int rc;
@@ -174,7 +190,7 @@ encrypt_dek (const DEK dek, ksba_cert_t cert, char **encval)
       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);
+  rc = gcry_sexp_sscan (&s_pkey, NULL, (char*)buf, len);
   xfree (buf); buf = NULL;
   if (rc)
     {
@@ -182,34 +198,27 @@ encrypt_dek (const DEK dek, ksba_cert_t cert, char **encval)
       return rc;
     }
 
-  /* put the encoded cleartext into a simple list */
+  /* Put the encoded cleartext into a simple list. */
+  s_data = NULL; /* (avoid compiler warning) */
   rc = encode_session_key (dek, &s_data);
   if (rc)
-  {
-    log_error ("encode_session_key failed: %s\n", gpg_strerror (rc));
-    return rc;
-  }
+    {
+      log_error ("encode_session_key failed: %s\n", gpg_strerror (rc));
+      return rc;
+    }
 
   /* pass it to libgcrypt */
   rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
   gcry_sexp_release (s_data);
   gcry_sexp_release (s_pkey);
-  
-  /* reformat it */
-  len = gcry_sexp_sprint (s_ciph, GCRYSEXP_FMT_CANON, NULL, 0);
-  assert (len); 
-  buf = xtrymalloc (len);
-  if (!buf)
+
+  /* Reformat it. */
+  if (!rc)
     {
-      gpg_error_t tmperr = OUT_OF_CORE (errno);
+      rc = make_canon_sexp (s_ciph, encval, NULL);
       gcry_sexp_release (s_ciph);
-      return tmperr;
     }
-  len = gcry_sexp_sprint (s_ciph, GCRYSEXP_FMT_CANON, buf, len);
-  assert (len);
-
-  *encval = buf;
-  return 0;
+  return rc;
 }
 
 
@@ -232,28 +241,28 @@ encrypt_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
 
   if (count < blklen)
     BUG ();
-     
+
   if (!parm->eof_seen)
     { /* fillup the buffer */
       p = parm->buffer;
       for (n=parm->buflen; n < parm->bufsize; n++)
         {
-          int c = getc (parm->fp);
+          int c = es_getc (parm->fp);
           if (c == EOF)
             {
-              if (ferror (parm->fp))
+              if (es_ferror (parm->fp))
                 {
                   parm->readerror = errno;
                   return -1;
                 }
               parm->eof_seen = 1;
-              break; 
+              break;
             }
           p[n] = c;
         }
       parm->buflen = n;
     }
-  
+
   n = parm->buflen < count? parm->buflen : count;
   n = n/blklen * blklen;
   if (n)
@@ -282,16 +291,16 @@ encrypt_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
 
 
 \f
-/* Perform an encrypt operation.  
+/* Perform an encrypt operation.
 
    Encrypt the data received on DATA-FD and write it to OUT_FP.  The
    recipients are take from the certificate given in recplist; if this
    is NULL it will be encrypted for a default recipient */
 int
-gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
+gpgsm_encrypt (ctrl_t ctrl, certlist_t recplist, int data_fd, estream_t out_fp)
 {
   int rc = 0;
-  Base64Context b64writer = NULL;
+  gnupg_ksba_io_t b64writer = NULL;
   gpg_error_t err;
   ksba_writer_t writer;
   ksba_reader_t reader = NULL;
@@ -301,11 +310,15 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   struct encrypt_cb_parm_s encparm;
   DEK dek = NULL;
   int recpno;
-  FILE *data_fp = NULL;
-  CERTLIST cl;
+  estream_t data_fp = NULL;
+  certlist_t cl;
+  int count;
+  int compliant;
 
   memset (&encparm, 0, sizeof encparm);
 
+  audit_set_type (ctrl->audit, AUDIT_TYPE_ENCRYPT);
+
   /* 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. */
@@ -316,22 +329,28 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
     {
       log_error(_("no valid recipients given\n"));
       gpgsm_status (ctrl, STATUS_NO_RECP, "0");
+      audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, 0);
       rc = gpg_error (GPG_ERR_NO_PUBKEY);
       goto leave;
     }
 
-  kh = keydb_new (0);
+  for (count = 0, cl = recplist; cl; cl = cl->next)
+    count++;
+  audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, count);
+
+  kh = keydb_new ();
   if (!kh)
     {
-      log_error (_("failed to allocated keyDB handle\n"));
+      log_error (_("failed to allocate keyDB handle\n"));
       rc = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
 
-  data_fp = fdopen ( dup (data_fd), "rb");
+  /* Fixme:  We should use the unlocked version of the es functions.  */
+  data_fp = es_fdopen_nc (data_fd, "rb");
   if (!data_fp)
     {
-      rc = gpg_error (gpg_err_code_from_errno (errno));
+      rc = gpg_error_from_syserror ();
       log_error ("fdopen() failed: %s\n", strerror (errno));
       goto leave;
     }
@@ -347,7 +366,10 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   encparm.fp = data_fp;
 
   ctrl->pem_name = "ENCRYPTED MESSAGE";
-  rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
+  rc = gnupg_ksba_create_writer
+    (&b64writer, ((ctrl->create_pem? GNUPG_KSBA_IO_PEM : 0)
+                  | (ctrl->create_base64? GNUPG_KSBA_IO_BASE64 : 0)),
+     ctrl->pem_name, out_fp, &writer);
   if (rc)
     {
       log_error ("can't create writer: %s\n", gpg_strerror (rc));
@@ -370,6 +392,8 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
       goto leave;
     }
 
+  audit_log (ctrl->audit, AUDIT_GOT_DATA);
+
   /* We are going to create enveloped data with uninterpreted data as
      inner content */
   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_ENVELOPED_DATA);
@@ -383,10 +407,33 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
       goto leave;
     }
 
-  /* create a session key */
-  dek = xtrycalloc (1, sizeof *dek); /* hmmm: should we put it into secmem?*/
+  /* Check compliance.  */
+  if (!gnupg_cipher_is_allowed
+      (opt.compliance, 1, gcry_cipher_map_name (opt.def_cipher_algoid),
+       gcry_cipher_mode_from_oid (opt.def_cipher_algoid)))
+    {
+      log_error (_("cipher algorithm '%s' may not be used in %s mode\n"),
+                opt.def_cipher_algoid,
+                gnupg_compliance_option_string (opt.compliance));
+      rc = gpg_error (GPG_ERR_CIPHER_ALGO);
+      goto leave;
+    }
+
+  if (!gnupg_rng_is_compliant (opt.compliance))
+    {
+      rc = gpg_error (GPG_ERR_FORBIDDEN);
+      log_error (_("%s is not compliant with %s mode\n"),
+                 "RNG",
+                 gnupg_compliance_option_string (opt.compliance));
+      gpgsm_status_with_error (ctrl, STATUS_ERROR,
+                               "random-compliance", rc);
+      goto leave;
+    }
+
+  /* Create a session key */
+  dek = xtrycalloc_secure (1, sizeof *dek);
   if (!dek)
-    rc = OUT_OF_CORE (errno);
+    rc = out_of_core ();
   else
   {
     dek->algoid = opt.def_cipher_algoid;
@@ -414,36 +461,66 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   encparm.buffer = xtrymalloc (encparm.bufsize);
   if (!encparm.buffer)
     {
-      rc = OUT_OF_CORE (errno);
+      rc = out_of_core ();
       goto leave;
     }
 
+  audit_log_s (ctrl->audit, AUDIT_SESSION_KEY, dek->algoid);
+
+  compliant = gnupg_cipher_is_compliant (CO_DE_VS, dek->algo,
+                                         GCRY_CIPHER_MODE_CBC);
+
   /* 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)
     {
-      char *encval;
-      
+      unsigned char *encval;
+      unsigned int nbits;
+      int pk_algo;
+
+      /* Check compliance.  */
+      pk_algo = gpgsm_get_key_algo_info (cl->cert, &nbits);
+      if (!gnupg_pk_is_compliant (opt.compliance, pk_algo, NULL, nbits, NULL))
+        {
+          char  kidstr[10+1];
+
+          snprintf (kidstr, sizeof kidstr, "0x%08lX",
+                    gpgsm_get_short_fingerprint (cl->cert, NULL));
+          log_info (_("WARNING: key %s is not suitable for encryption"
+                      " in %s mode\n"),
+                    kidstr,
+                    gnupg_compliance_option_string (opt.compliance));
+        }
+
+      /* Fixme: When adding ECC we need to provide the curvename and
+       * the key to gnupg_pk_is_compliant.  */
+      if (compliant
+          && !gnupg_pk_is_compliant (CO_DE_VS, pk_algo, NULL, nbits, NULL))
+        compliant = 0;
+
       rc = encrypt_dek (dek, cl->cert, &encval);
       if (rc)
         {
+          audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, rc);
           log_error ("encryption failed for recipient no. %d: %s\n",
                      recpno, gpg_strerror (rc));
           goto leave;
         }
-      
+
       err = ksba_cms_add_recipient (cms, cl->cert);
       if (err)
         {
+          audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
           log_error ("ksba_cms_add_recipient failed: %s\n",
                      gpg_strerror (err));
           rc = err;
           xfree (encval);
           goto leave;
         }
-      
+
       err = ksba_cms_set_enc_val (cms, recpno, encval);
       xfree (encval);
+      audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
       if (err)
         {
           log_error ("ksba_cms_set_enc_val failed: %s\n",
@@ -451,11 +528,15 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
           rc = err;
           goto leave;
         }
-  }
+    }
+
+  if (compliant)
+    gpgsm_status (ctrl, STATUS_ENCRYPTION_COMPLIANCE_MODE,
+                  gnupg_status_compliance_flag (CO_DE_VS));
 
   /* Main control loop for encryption. */
   recpno = 0;
-  do 
+  do
     {
       err = ksba_cms_build (cms, &stopreason);
       if (err)
@@ -465,7 +546,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
           goto leave;
         }
     }
-  while (stopreason != KSBA_SR_READY);   
+  while (stopreason != KSBA_SR_READY);
 
   if (encparm.readerror)
     {
@@ -475,22 +556,22 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
     }
 
 
-  rc = gpgsm_finish_writer (b64writer);
-  if (rc) 
+  rc = gnupg_ksba_finish_writer (b64writer);
+  if (rc)
     {
       log_error ("write failed: %s\n", gpg_strerror (rc));
       goto leave;
     }
+  audit_log (ctrl->audit, AUDIT_ENCRYPTION_DONE);
   log_info ("encrypted data created\n");
 
  leave:
   ksba_cms_release (cms);
-  gpgsm_destroy_writer (b64writer);
+  gnupg_ksba_destroy_writer (b64writer);
   ksba_reader_release (reader);
-  keydb_release (kh); 
+  keydb_release (kh);
   xfree (dek);
-  if (data_fp)
-    fclose (data_fp);
+  es_fclose (data_fp);
   xfree (encparm.buffer);
   return rc;
 }