sm/encrypt.c

   1 /* encrypt.c - Encrypt a message
   2  * Copyright (C) 2001, 2003, 2004, 2007, 2008,
   3  *               2010 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 <https://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 <unistd.h>
  27 #include <time.h>
  28 #include <assert.h>
  29
  30 #include "gpgsm.h"
  31 #include <gcrypt.h>
  32 #include <ksba.h>
  33
  34 #include "keydb.h"
  35 #include "i18n.h"
  36
  37
  38 struct dek_s {
  39   const char *algoid;
  40   int algo;
  41   gcry_cipher_hd_t chd;
  42   char key[32];
  43   int keylen;
  44   char iv[32];
  45   int ivlen;
  46 };
  47 typedef struct dek_s *DEK;
  48
  49
  50 /* Callback parameters for the encryption.  */
  51 struct encrypt_cb_parm_s
  52 {
  53   estream_t fp;
  54   DEK dek;
  55   int eof_seen;
  56   int ready;
  57   int readerror;
  58   int bufsize;
  59   unsigned char *buffer;
  60   int buflen;
  61 };
  62
  63
  64
  65
  66 \f
  67 /* Initialize the data encryption key (session key). */
  68 static int
  69 init_dek (DEK dek)
  70 {
  71   int rc=0, mode, i;
  72
  73   dek->algo = gcry_cipher_map_name (dek->algoid);
  74   mode = gcry_cipher_mode_from_oid (dek->algoid);
  75   if (!dek->algo || !mode)
  76     {
  77       log_error ("unsupported algorithm '%s'\n", dek->algoid);
  78       return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
  79     }
  80
  81   /* Extra check for algorithms we consider to be too weak for
  82      encryption, although we support them for decryption.  Note that
  83      there is another check below discriminating on the key length. */
  84   switch (dek->algo)
  85     {
  86     case GCRY_CIPHER_DES:
  87     case GCRY_CIPHER_RFC2268_40:
  88       log_error ("cipher algorithm '%s' not allowed: too weak\n",
  89                  gnupg_cipher_algo_name (dek->algo));
  90       return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
  91     default:
  92       break;
  93     }
  94
  95   dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
  96   if (!dek->keylen || dek->keylen > sizeof (dek->key))
  97     return gpg_error (GPG_ERR_BUG);
  98
  99   dek->ivlen = gcry_cipher_get_algo_blklen (dek->algo);
 100   if (!dek->ivlen || dek->ivlen > sizeof (dek->iv))
 101     return gpg_error (GPG_ERR_BUG);
 102
 103   /* Make sure we don't use weak keys. */
 104   if (dek->keylen < 100/8)
 105     {
 106       log_error ("key length of '%s' too small\n", dek->algoid);
 107       return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
 108     }
 109
 110   rc = gcry_cipher_open (&dek->chd, dek->algo, mode, GCRY_CIPHER_SECURE);
 111   if (rc)
 112     {
 113       log_error ("failed to create cipher context: %s\n", gpg_strerror (rc));
 114       return rc;
 115     }
 116
 117   for (i=0; i < 8; i++)
 118     {
 119       gcry_randomize (dek->key, dek->keylen, GCRY_STRONG_RANDOM );
 120       rc = gcry_cipher_setkey (dek->chd, dek->key, dek->keylen);
 121       if (gpg_err_code (rc) != GPG_ERR_WEAK_KEY)
 122         break;
 123       log_info(_("weak key created - retrying\n") );
 124     }
 125   if (rc)
 126     {
 127       log_error ("failed to set the key: %s\n", gpg_strerror (rc));
 128       gcry_cipher_close (dek->chd);
 129       dek->chd = NULL;
 130       return rc;
 131     }
 132
 133   gcry_create_nonce (dek->iv, dek->ivlen);
 134   rc = gcry_cipher_setiv (dek->chd, dek->iv, dek->ivlen);
 135   if (rc)
 136     {
 137       log_error ("failed to set the IV: %s\n", gpg_strerror (rc));
 138       gcry_cipher_close (dek->chd);
 139       dek->chd = NULL;
 140       return rc;
 141     }
 142
 143   return 0;
 144 }
 145
 146
 147 static int
 148 encode_session_key (DEK dek, gcry_sexp_t * r_data)
 149 {
 150   gcry_sexp_t data;
 151   char *p;
 152   int rc;
 153
 154   p = xtrymalloc (64 + 2 * dek->keylen);
 155   if (!p)
 156     return gpg_error_from_syserror ();
 157   strcpy (p, "(data\n (flags pkcs1)\n (value #");
 158   bin2hex (dek->key, dek->keylen, p + strlen (p));
 159   strcat (p, "#))\n");
 160   rc = gcry_sexp_sscan (&data, NULL, p, strlen (p));
 161   xfree (p);
 162   *r_data = data;
 163   return rc;
 164 }
 165
 166
 167 /* Encrypt the DEK under the key contained in CERT and return it as a
 168    canonical S-Exp in encval. */
 169 static int
 170 encrypt_dek (const DEK dek, ksba_cert_t cert, unsigned char **encval)
 171 {
 172   gcry_sexp_t s_ciph, s_data, s_pkey;
 173   int rc;
 174   ksba_sexp_t buf;
 175   size_t len;
 176
 177   *encval = NULL;
 178
 179   /* get the key from the cert */
 180   buf = ksba_cert_get_public_key (cert);
 181   if (!buf)
 182     {
 183       log_error ("no public key for recipient\n");
 184       return gpg_error (GPG_ERR_NO_PUBKEY);
 185     }
 186   len = gcry_sexp_canon_len (buf, 0, NULL, NULL);
 187   if (!len)
 188     {
 189       log_error ("libksba did not return a proper S-Exp\n");
 190       return gpg_error (GPG_ERR_BUG);
 191     }
 192   rc = gcry_sexp_sscan (&s_pkey, NULL, (char*)buf, len);
 193   xfree (buf); buf = NULL;
 194   if (rc)
 195     {
 196       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
 197       return rc;
 198     }
 199
 200   /* Put the encoded cleartext into a simple list. */
 201   s_data = NULL; /* (avoid compiler warning) */
 202   rc = encode_session_key (dek, &s_data);
 203   if (rc)
 204     {
 205       log_error ("encode_session_key failed: %s\n", gpg_strerror (rc));
 206       return rc;
 207     }
 208
 209   /* pass it to libgcrypt */
 210   rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
 211   gcry_sexp_release (s_data);
 212   gcry_sexp_release (s_pkey);
 213
 214   /* Reformat it. */
 215   if (!rc)
 216     {
 217       rc = make_canon_sexp (s_ciph, encval, NULL);
 218       gcry_sexp_release (s_ciph);
 219     }
 220   return rc;
 221 }
 222
 223
 224 \f
 225 /* do the actual encryption */
 226 static int
 227 encrypt_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
 228 {
 229   struct encrypt_cb_parm_s *parm = cb_value;
 230   int blklen = parm->dek->ivlen;
 231   unsigned char *p;
 232   size_t n;
 233
 234   *nread = 0;
 235   if (!buffer)
 236     return -1; /* not supported */
 237
 238   if (parm->ready)
 239     return -1;
 240
 241   if (count < blklen)
 242     BUG ();
 243
 244   if (!parm->eof_seen)
 245     { /* fillup the buffer */
 246       p = parm->buffer;
 247       for (n=parm->buflen; n < parm->bufsize; n++)
 248         {
 249           int c = es_getc (parm->fp);
 250           if (c == EOF)
 251             {
 252               if (es_ferror (parm->fp))
 253                 {
 254                   parm->readerror = errno;
 255                   return -1;
 256                 }
 257               parm->eof_seen = 1;
 258               break;
 259             }
 260           p[n] = c;
 261         }
 262       parm->buflen = n;
 263     }
 264
 265   n = parm->buflen < count? parm->buflen : count;
 266   n = n/blklen * blklen;
 267   if (n)
 268     { /* encrypt the stuff */
 269       gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
 270       *nread = n;
 271       /* Who cares about cycles, take the easy way and shift the buffer */
 272       parm->buflen -= n;
 273       memmove (parm->buffer, parm->buffer+n, parm->buflen);
 274     }
 275   else if (parm->eof_seen)
 276     { /* no complete block but eof: add padding */
 277       /* fixme: we should try to do this also in the above code path */
 278       int i, npad = blklen - (parm->buflen % blklen);
 279       p = parm->buffer;
 280       for (n=parm->buflen, i=0; n < parm->bufsize && i < npad; n++, i++)
 281         p[n] = npad;
 282       gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
 283       *nread = n;
 284       parm->ready = 1;
 285     }
 286
 287   return 0;
 288 }
 289
 290
 291
 292 \f
 293 /* Perform an encrypt operation.
 294
 295    Encrypt the data received on DATA-FD and write it to OUT_FP.  The
 296    recipients are take from the certificate given in recplist; if this
 297    is NULL it will be encrypted for a default recipient */
 298 int
 299 gpgsm_encrypt (ctrl_t ctrl, certlist_t recplist, int data_fd, estream_t out_fp)
 300 {
 301   int rc = 0;
 302   gnupg_ksba_io_t b64writer = NULL;
 303   gpg_error_t err;
 304   ksba_writer_t writer;
 305   ksba_reader_t reader = NULL;
 306   ksba_cms_t cms = NULL;
 307   ksba_stop_reason_t stopreason;
 308   KEYDB_HANDLE kh = NULL;
 309   struct encrypt_cb_parm_s encparm;
 310   DEK dek = NULL;
 311   int recpno;
 312   estream_t data_fp = NULL;
 313   certlist_t cl;
 314   int count;
 315
 316   memset (&encparm, 0, sizeof encparm);
 317
 318   audit_set_type (ctrl->audit, AUDIT_TYPE_ENCRYPT);
 319
 320   /* Check that the certificate list is not empty and that at least
 321      one certificate is not flagged as encrypt_to; i.e. is a real
 322      recipient. */
 323   for (cl = recplist; cl; cl = cl->next)
 324     if (!cl->is_encrypt_to)
 325       break;
 326   if (!cl)
 327     {
 328       log_error(_("no valid recipients given\n"));
 329       gpgsm_status (ctrl, STATUS_NO_RECP, "0");
 330       audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, 0);
 331       rc = gpg_error (GPG_ERR_NO_PUBKEY);
 332       goto leave;
 333     }
 334
 335   for (count = 0, cl = recplist; cl; cl = cl->next)
 336     count++;
 337   audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, count);
 338
 339   kh = keydb_new ();
 340   if (!kh)
 341     {
 342       log_error (_("failed to allocate keyDB handle\n"));
 343       rc = gpg_error (GPG_ERR_GENERAL);
 344       goto leave;
 345     }
 346
 347   /* Fixme:  We should use the unlocked version of the es functions.  */
 348   data_fp = es_fdopen_nc (data_fd, "rb");
 349   if (!data_fp)
 350     {
 351       rc = gpg_error_from_syserror ();
 352       log_error ("fdopen() failed: %s\n", strerror (errno));
 353       goto leave;
 354     }
 355
 356   err = ksba_reader_new (&reader);
 357   if (err)
 358       rc = err;
 359   if (!rc)
 360     rc = ksba_reader_set_cb (reader, encrypt_cb, &encparm);
 361   if (rc)
 362       goto leave;
 363
 364   encparm.fp = data_fp;
 365
 366   ctrl->pem_name = "ENCRYPTED MESSAGE";
 367   rc = gnupg_ksba_create_writer
 368     (&b64writer, ((ctrl->create_pem? GNUPG_KSBA_IO_PEM : 0)
 369                   | (ctrl->create_base64? GNUPG_KSBA_IO_BASE64 : 0)),
 370      ctrl->pem_name, out_fp, &writer);
 371   if (rc)
 372     {
 373       log_error ("can't create writer: %s\n", gpg_strerror (rc));
 374       goto leave;
 375     }
 376
 377   err = ksba_cms_new (&cms);
 378   if (err)
 379     {
 380       rc = err;
 381       goto leave;
 382     }
 383
 384   err = ksba_cms_set_reader_writer (cms, reader, writer);
 385   if (err)
 386     {
 387       log_debug ("ksba_cms_set_reader_writer failed: %s\n",
 388                  gpg_strerror (err));
 389       rc = err;
 390       goto leave;
 391     }
 392
 393   audit_log (ctrl->audit, AUDIT_GOT_DATA);
 394
 395   /* We are going to create enveloped data with uninterpreted data as
 396      inner content */
 397   err = ksba_cms_set_content_type (cms, 0, KSBA_CT_ENVELOPED_DATA);
 398   if (!err)
 399     err = ksba_cms_set_content_type (cms, 1, KSBA_CT_DATA);
 400   if (err)
 401     {
 402       log_debug ("ksba_cms_set_content_type failed: %s\n",
 403                  gpg_strerror (err));
 404       rc = err;
 405       goto leave;
 406     }
 407
 408   /* Create a session key */
 409   dek = xtrycalloc_secure (1, sizeof *dek);
 410   if (!dek)
 411     rc = out_of_core ();
 412   else
 413   {
 414     dek->algoid = opt.def_cipher_algoid;
 415     rc = init_dek (dek);
 416   }
 417   if (rc)
 418     {
 419       log_error ("failed to create the session key: %s\n",
 420                  gpg_strerror (rc));
 421       goto leave;
 422     }
 423
 424   err = ksba_cms_set_content_enc_algo (cms, dek->algoid, dek->iv, dek->ivlen);
 425   if (err)
 426     {
 427       log_error ("ksba_cms_set_content_enc_algo failed: %s\n",
 428                  gpg_strerror (err));
 429       rc = err;
 430       goto leave;
 431     }
 432
 433   encparm.dek = dek;
 434   /* Use a ~8k (AES) or ~4k (3DES) buffer */
 435   encparm.bufsize = 500 * dek->ivlen;
 436   encparm.buffer = xtrymalloc (encparm.bufsize);
 437   if (!encparm.buffer)
 438     {
 439       rc = out_of_core ();
 440       goto leave;
 441     }
 442
 443   audit_log_s (ctrl->audit, AUDIT_SESSION_KEY, dek->algoid);
 444
 445   /* Gather certificates of recipients, encrypt the session key for
 446      each and store them in the CMS object */
 447   for (recpno = 0, cl = recplist; cl; recpno++, cl = cl->next)
 448     {
 449       unsigned char *encval;
 450
 451       rc = encrypt_dek (dek, cl->cert, &encval);
 452       if (rc)
 453         {
 454           audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, rc);
 455           log_error ("encryption failed for recipient no. %d: %s\n",
 456                      recpno, gpg_strerror (rc));
 457           goto leave;
 458         }
 459
 460       err = ksba_cms_add_recipient (cms, cl->cert);
 461       if (err)
 462         {
 463           audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
 464           log_error ("ksba_cms_add_recipient failed: %s\n",
 465                      gpg_strerror (err));
 466           rc = err;
 467           xfree (encval);
 468           goto leave;
 469         }
 470
 471       err = ksba_cms_set_enc_val (cms, recpno, encval);
 472       xfree (encval);
 473       audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
 474       if (err)
 475         {
 476           log_error ("ksba_cms_set_enc_val failed: %s\n",
 477                      gpg_strerror (err));
 478           rc = err;
 479           goto leave;
 480         }
 481     }
 482
 483   /* Main control loop for encryption. */
 484   recpno = 0;
 485   do
 486     {
 487       err = ksba_cms_build (cms, &stopreason);
 488       if (err)
 489         {
 490           log_debug ("ksba_cms_build failed: %s\n", gpg_strerror (err));
 491           rc = err;
 492           goto leave;
 493         }
 494     }
 495   while (stopreason != KSBA_SR_READY);
 496
 497   if (encparm.readerror)
 498     {
 499       log_error ("error reading input: %s\n", strerror (encparm.readerror));
 500       rc = gpg_error (gpg_err_code_from_errno (encparm.readerror));
 501       goto leave;
 502     }
 503
 504
 505   rc = gnupg_ksba_finish_writer (b64writer);
 506   if (rc)
 507     {
 508       log_error ("write failed: %s\n", gpg_strerror (rc));
 509       goto leave;
 510     }
 511   audit_log (ctrl->audit, AUDIT_ENCRYPTION_DONE);
 512   log_info ("encrypted data created\n");
 513
 514  leave:
 515   ksba_cms_release (cms);
 516   gnupg_ksba_destroy_writer (b64writer);
 517   ksba_reader_release (reader);
 518   keydb_release (kh);
 519   xfree (dek);
 520   es_fclose (data_fp);
 521   xfree (encparm.buffer);
 522   return rc;
 523 }