2003-08-05 17:11:04 +00:00
|
|
|
|
/* encrypt.c - Encrypt a message
|
2010-03-08 12:22:18 +00:00
|
|
|
|
* Copyright (C) 2001, 2003, 2004, 2007, 2008,
|
|
|
|
|
* 2010 Free Software Foundation, Inc.
|
2003-08-05 17:11:04 +00:00
|
|
|
|
*
|
|
|
|
|
* 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
|
2007-07-04 19:49:40 +00:00
|
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
2003-08-05 17:11:04 +00:00
|
|
|
|
* (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* GnuPG is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2016-11-05 12:02:19 +01:00
|
|
|
|
* along with this program; if not, see <https://www.gnu.org/licenses/>.
|
2003-08-05 17:11:04 +00:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <errno.h>
|
2011-02-04 12:57:53 +01:00
|
|
|
|
#include <unistd.h>
|
2003-08-05 17:11:04 +00:00
|
|
|
|
#include <time.h>
|
|
|
|
|
#include <assert.h>
|
|
|
|
|
|
|
|
|
|
#include "gpgsm.h"
|
|
|
|
|
#include <gcrypt.h>
|
|
|
|
|
#include <ksba.h>
|
|
|
|
|
|
|
|
|
|
#include "keydb.h"
|
2017-03-07 20:21:23 +09:00
|
|
|
|
#include "../common/i18n.h"
|
2017-06-06 16:01:40 +02:00
|
|
|
|
#include "../common/compliance.h"
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct dek_s {
|
|
|
|
|
const char *algoid;
|
|
|
|
|
int algo;
|
|
|
|
|
gcry_cipher_hd_t chd;
|
|
|
|
|
char key[32];
|
|
|
|
|
int keylen;
|
|
|
|
|
char iv[32];
|
|
|
|
|
int ivlen;
|
|
|
|
|
};
|
|
|
|
|
typedef struct dek_s *DEK;
|
|
|
|
|
|
2010-03-08 12:22:18 +00:00
|
|
|
|
|
|
|
|
|
/* Callback parameters for the encryption. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
struct encrypt_cb_parm_s
|
2010-03-08 12:22:18 +00:00
|
|
|
|
{
|
|
|
|
|
estream_t fp;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
DEK dek;
|
|
|
|
|
int eof_seen;
|
|
|
|
|
int ready;
|
|
|
|
|
int readerror;
|
|
|
|
|
int bufsize;
|
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
int buflen;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2003-12-16 11:31:46 +00:00
|
|
|
|
/* Initialize the data encryption key (session key). */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
static int
|
|
|
|
|
init_dek (DEK dek)
|
|
|
|
|
{
|
|
|
|
|
int rc=0, mode, i;
|
|
|
|
|
|
|
|
|
|
dek->algo = gcry_cipher_map_name (dek->algoid);
|
|
|
|
|
mode = gcry_cipher_mode_from_oid (dek->algoid);
|
|
|
|
|
if (!dek->algo || !mode)
|
|
|
|
|
{
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_error ("unsupported algorithm '%s'\n", dek->algoid);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2007-02-26 20:24:29 +00:00
|
|
|
|
/* Extra check for algorithms we consider to be too weak for
|
|
|
|
|
encryption, although we support them for decryption. Note that
|
2004-02-13 12:40:23 +00:00
|
|
|
|
there is another check below discriminating on the key length. */
|
|
|
|
|
switch (dek->algo)
|
|
|
|
|
{
|
|
|
|
|
case GCRY_CIPHER_DES:
|
|
|
|
|
case GCRY_CIPHER_RFC2268_40:
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_error ("cipher algorithm '%s' not allowed: too weak\n",
|
2010-12-02 15:49:02 +00:00
|
|
|
|
gnupg_cipher_algo_name (dek->algo));
|
2004-02-13 12:40:23 +00:00
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
|
|
|
|
|
if (!dek->keylen || dek->keylen > sizeof (dek->key))
|
|
|
|
|
return gpg_error (GPG_ERR_BUG);
|
|
|
|
|
|
|
|
|
|
dek->ivlen = gcry_cipher_get_algo_blklen (dek->algo);
|
|
|
|
|
if (!dek->ivlen || dek->ivlen > sizeof (dek->iv))
|
|
|
|
|
return gpg_error (GPG_ERR_BUG);
|
|
|
|
|
|
2004-02-13 12:40:23 +00:00
|
|
|
|
/* Make sure we don't use weak keys. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (dek->keylen < 100/8)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
{
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_error ("key length of '%s' too small\n", dek->algoid);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
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 (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", gpg_strerror (rc));
|
|
|
|
|
gcry_cipher_close (dek->chd);
|
|
|
|
|
dek->chd = NULL;
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2003-12-16 11:31:46 +00:00
|
|
|
|
gcry_create_nonce (dek->iv, dek->ivlen);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
rc = gcry_cipher_setiv (dek->chd, dek->iv, dek->ivlen);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
log_error ("failed to set the IV: %s\n", gpg_strerror (rc));
|
|
|
|
|
gcry_cipher_close (dek->chd);
|
|
|
|
|
dek->chd = NULL;
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-08-14 19:39:30 +00:00
|
|
|
|
static int
|
|
|
|
|
encode_session_key (DEK dek, gcry_sexp_t * r_data)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{
|
2003-08-14 19:39:30 +00:00
|
|
|
|
gcry_sexp_t data;
|
2008-06-23 14:43:14 +00:00
|
|
|
|
char *p;
|
2003-08-14 19:39:30 +00:00
|
|
|
|
int rc;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
2008-06-23 14:43:14 +00:00
|
|
|
|
p = xtrymalloc (64 + 2 * dek->keylen);
|
|
|
|
|
if (!p)
|
|
|
|
|
return gpg_error_from_syserror ();
|
2003-08-14 19:39:30 +00:00
|
|
|
|
strcpy (p, "(data\n (flags pkcs1)\n (value #");
|
2008-06-23 14:43:14 +00:00
|
|
|
|
bin2hex (dek->key, dek->keylen, p + strlen (p));
|
2003-08-14 19:39:30 +00:00
|
|
|
|
strcat (p, "#))\n");
|
|
|
|
|
rc = gcry_sexp_sscan (&data, NULL, p, strlen (p));
|
2003-08-05 17:11:04 +00:00
|
|
|
|
xfree (p);
|
2003-08-14 19:39:30 +00:00
|
|
|
|
*r_data = data;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
return rc;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-06-16 08:12:03 +00:00
|
|
|
|
/* Encrypt the DEK under the key contained in CERT and return it as a
|
|
|
|
|
canonical S-Exp in encval. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
static int
|
2005-06-16 08:12:03 +00:00
|
|
|
|
encrypt_dek (const DEK dek, ksba_cert_t cert, unsigned char **encval)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{
|
|
|
|
|
gcry_sexp_t s_ciph, s_data, s_pkey;
|
|
|
|
|
int rc;
|
2003-12-17 12:28:24 +00:00
|
|
|
|
ksba_sexp_t buf;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
|
|
*encval = NULL;
|
|
|
|
|
|
|
|
|
|
/* get the key from the cert */
|
|
|
|
|
buf = ksba_cert_get_public_key (cert);
|
|
|
|
|
if (!buf)
|
|
|
|
|
{
|
|
|
|
|
log_error ("no public key for recipient\n");
|
|
|
|
|
return gpg_error (GPG_ERR_NO_PUBKEY);
|
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
|
}
|
2005-06-16 08:12:03 +00:00
|
|
|
|
rc = gcry_sexp_sscan (&s_pkey, NULL, (char*)buf, len);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
xfree (buf); buf = NULL;
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-23 14:43:14 +00:00
|
|
|
|
/* Put the encoded cleartext into a simple list. */
|
|
|
|
|
s_data = NULL; /* (avoid compiler warning) */
|
2003-08-14 19:39:30 +00:00
|
|
|
|
rc = encode_session_key (dek, &s_data);
|
2003-08-20 16:53:40 +00:00
|
|
|
|
if (rc)
|
2008-06-23 14:43:14 +00:00
|
|
|
|
{
|
2021-05-20 14:51:42 +02:00
|
|
|
|
gcry_sexp_release (s_pkey);
|
2008-06-23 14:43:14 +00:00
|
|
|
|
log_error ("encode_session_key failed: %s\n", gpg_strerror (rc));
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
/* pass it to libgcrypt */
|
|
|
|
|
rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
|
|
|
|
|
gcry_sexp_release (s_data);
|
|
|
|
|
gcry_sexp_release (s_pkey);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-06-02 15:46:59 +00:00
|
|
|
|
/* Reformat it. */
|
2015-12-15 12:38:25 +09:00
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
|
|
|
|
rc = make_canon_sexp (s_ciph, encval, NULL);
|
|
|
|
|
gcry_sexp_release (s_ciph);
|
|
|
|
|
}
|
2009-06-02 15:46:59 +00:00
|
|
|
|
return rc;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* do the actual encryption */
|
|
|
|
|
static int
|
|
|
|
|
encrypt_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
|
|
|
|
|
{
|
|
|
|
|
struct encrypt_cb_parm_s *parm = cb_value;
|
|
|
|
|
int blklen = parm->dek->ivlen;
|
|
|
|
|
unsigned char *p;
|
|
|
|
|
size_t n;
|
|
|
|
|
|
|
|
|
|
*nread = 0;
|
|
|
|
|
if (!buffer)
|
|
|
|
|
return -1; /* not supported */
|
|
|
|
|
|
|
|
|
|
if (parm->ready)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
if (count < blklen)
|
|
|
|
|
BUG ();
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (!parm->eof_seen)
|
|
|
|
|
{ /* fillup the buffer */
|
|
|
|
|
p = parm->buffer;
|
|
|
|
|
for (n=parm->buflen; n < parm->bufsize; n++)
|
|
|
|
|
{
|
2010-03-08 12:22:18 +00:00
|
|
|
|
int c = es_getc (parm->fp);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (c == EOF)
|
|
|
|
|
{
|
2010-03-08 12:22:18 +00:00
|
|
|
|
if (es_ferror (parm->fp))
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{
|
|
|
|
|
parm->readerror = errno;
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
parm->eof_seen = 1;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
}
|
|
|
|
|
p[n] = c;
|
|
|
|
|
}
|
|
|
|
|
parm->buflen = n;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
n = parm->buflen < count? parm->buflen : count;
|
|
|
|
|
n = n/blklen * blklen;
|
|
|
|
|
if (n)
|
|
|
|
|
{ /* encrypt the stuff */
|
|
|
|
|
gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
|
|
|
|
|
*nread = n;
|
|
|
|
|
/* Who cares about cycles, take the easy way and shift the buffer */
|
|
|
|
|
parm->buflen -= n;
|
|
|
|
|
memmove (parm->buffer, parm->buffer+n, parm->buflen);
|
|
|
|
|
}
|
|
|
|
|
else if (parm->eof_seen)
|
|
|
|
|
{ /* no complete block but eof: add padding */
|
|
|
|
|
/* fixme: we should try to do this also in the above code path */
|
|
|
|
|
int i, npad = blklen - (parm->buflen % blklen);
|
|
|
|
|
p = parm->buffer;
|
|
|
|
|
for (n=parm->buflen, i=0; n < parm->bufsize && i < npad; n++, i++)
|
|
|
|
|
p[n] = npad;
|
|
|
|
|
gcry_cipher_encrypt (parm->dek->chd, buffer, n, parm->buffer, n);
|
|
|
|
|
*nread = n;
|
|
|
|
|
parm->ready = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
/* Perform an encrypt operation.
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
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
|
2010-03-08 12:22:18 +00:00
|
|
|
|
gpgsm_encrypt (ctrl_t ctrl, certlist_t recplist, int data_fd, estream_t out_fp)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
2017-02-16 17:11:38 +01:00
|
|
|
|
gnupg_ksba_io_t b64writer = NULL;
|
2003-12-17 12:28:24 +00:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
ksba_writer_t writer;
|
|
|
|
|
ksba_reader_t reader = NULL;
|
|
|
|
|
ksba_cms_t cms = NULL;
|
|
|
|
|
ksba_stop_reason_t stopreason;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
KEYDB_HANDLE kh = NULL;
|
|
|
|
|
struct encrypt_cb_parm_s encparm;
|
|
|
|
|
DEK dek = NULL;
|
|
|
|
|
int recpno;
|
2010-03-08 12:22:18 +00:00
|
|
|
|
estream_t data_fp = NULL;
|
2006-09-06 16:35:52 +00:00
|
|
|
|
certlist_t cl;
|
2007-12-12 10:28:30 +00:00
|
|
|
|
int count;
|
2017-06-20 09:25:56 +02:00
|
|
|
|
int compliant;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
memset (&encparm, 0, sizeof encparm);
|
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
|
audit_set_type (ctrl->audit, AUDIT_TYPE_ENCRYPT);
|
|
|
|
|
|
2003-12-17 17:12:14 +00:00
|
|
|
|
/* 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)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{
|
|
|
|
|
log_error(_("no valid recipients given\n"));
|
|
|
|
|
gpgsm_status (ctrl, STATUS_NO_RECP, "0");
|
2007-12-12 10:28:30 +00:00
|
|
|
|
audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, 0);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
rc = gpg_error (GPG_ERR_NO_PUBKEY);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
|
for (count = 0, cl = recplist; cl; cl = cl->next)
|
|
|
|
|
count++;
|
|
|
|
|
audit_log_i (ctrl->audit, AUDIT_GOT_RECIPIENTS, count);
|
|
|
|
|
|
2016-11-10 15:38:14 +01:00
|
|
|
|
kh = keydb_new ();
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (!kh)
|
|
|
|
|
{
|
2012-08-22 12:54:38 -04:00
|
|
|
|
log_error (_("failed to allocate keyDB handle\n"));
|
2003-08-05 17:11:04 +00:00
|
|
|
|
rc = gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-08 12:22:18 +00:00
|
|
|
|
/* Fixme: We should use the unlocked version of the es functions. */
|
|
|
|
|
data_fp = es_fdopen_nc (data_fd, "rb");
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (!data_fp)
|
|
|
|
|
{
|
2010-03-08 12:22:18 +00:00
|
|
|
|
rc = gpg_error_from_syserror ();
|
2003-08-05 17:11:04 +00:00
|
|
|
|
log_error ("fdopen() failed: %s\n", strerror (errno));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2003-11-12 15:17:44 +00:00
|
|
|
|
err = ksba_reader_new (&reader);
|
|
|
|
|
if (err)
|
|
|
|
|
rc = err;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (!rc)
|
|
|
|
|
rc = ksba_reader_set_cb (reader, encrypt_cb, &encparm);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto leave;
|
2003-11-12 15:17:44 +00:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
encparm.fp = data_fp;
|
|
|
|
|
|
|
|
|
|
ctrl->pem_name = "ENCRYPTED MESSAGE";
|
2017-02-16 15:16:48 +01:00
|
|
|
|
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);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
log_error ("can't create writer: %s\n", gpg_strerror (rc));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2003-11-12 15:17:44 +00:00
|
|
|
|
err = ksba_cms_new (&cms);
|
|
|
|
|
if (err)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{
|
2003-11-12 15:17:44 +00:00
|
|
|
|
rc = err;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = ksba_cms_set_reader_writer (cms, reader, writer);
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
log_debug ("ksba_cms_set_reader_writer failed: %s\n",
|
2003-11-12 15:17:44 +00:00
|
|
|
|
gpg_strerror (err));
|
|
|
|
|
rc = err;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
|
audit_log (ctrl->audit, AUDIT_GOT_DATA);
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
/* 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);
|
|
|
|
|
if (!err)
|
|
|
|
|
err = ksba_cms_set_content_type (cms, 1, KSBA_CT_DATA);
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
log_debug ("ksba_cms_set_content_type failed: %s\n",
|
2003-11-12 15:17:44 +00:00
|
|
|
|
gpg_strerror (err));
|
|
|
|
|
rc = err;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-06 16:01:40 +02:00
|
|
|
|
/* Check compliance. */
|
2017-06-20 08:31:07 +02:00
|
|
|
|
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)))
|
2017-06-06 16:01:40 +02:00
|
|
|
|
{
|
2017-07-28 17:46:43 +02:00
|
|
|
|
log_error (_("cipher algorithm '%s' may not be used in %s mode\n"),
|
2017-06-06 16:01:40 +02:00
|
|
|
|
opt.def_cipher_algoid,
|
|
|
|
|
gnupg_compliance_option_string (opt.compliance));
|
|
|
|
|
rc = gpg_error (GPG_ERR_CIPHER_ALGO);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-17 15:52:26 +02:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2004-06-06 13:00:59 +00:00
|
|
|
|
/* Create a session key */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
dek = xtrycalloc_secure (1, sizeof *dek);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (!dek)
|
2006-09-06 16:35:52 +00:00
|
|
|
|
rc = out_of_core ();
|
2003-08-05 17:11:04 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
dek->algoid = opt.def_cipher_algoid;
|
|
|
|
|
rc = init_dek (dek);
|
|
|
|
|
}
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
log_error ("failed to create the session key: %s\n",
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = ksba_cms_set_content_enc_algo (cms, dek->algoid, dek->iv, dek->ivlen);
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
log_error ("ksba_cms_set_content_enc_algo failed: %s\n",
|
2003-11-12 15:17:44 +00:00
|
|
|
|
gpg_strerror (err));
|
|
|
|
|
rc = err;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
encparm.dek = dek;
|
|
|
|
|
/* Use a ~8k (AES) or ~4k (3DES) buffer */
|
|
|
|
|
encparm.bufsize = 500 * dek->ivlen;
|
|
|
|
|
encparm.buffer = xtrymalloc (encparm.bufsize);
|
|
|
|
|
if (!encparm.buffer)
|
|
|
|
|
{
|
2006-09-06 16:35:52 +00:00
|
|
|
|
rc = out_of_core ();
|
2003-08-05 17:11:04 +00:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
|
audit_log_s (ctrl->audit, AUDIT_SESSION_KEY, dek->algoid);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
2017-06-20 09:25:56 +02:00
|
|
|
|
compliant = gnupg_cipher_is_compliant (CO_DE_VS, dek->algo,
|
|
|
|
|
GCRY_CIPHER_MODE_CBC);
|
|
|
|
|
|
2003-12-17 17:12:14 +00:00
|
|
|
|
/* Gather certificates of recipients, encrypt the session key for
|
2003-08-05 17:11:04 +00:00
|
|
|
|
each and store them in the CMS object */
|
|
|
|
|
for (recpno = 0, cl = recplist; cl; recpno++, cl = cl->next)
|
|
|
|
|
{
|
2005-06-16 08:12:03 +00:00
|
|
|
|
unsigned char *encval;
|
2017-06-20 09:25:56 +02:00
|
|
|
|
unsigned int nbits;
|
|
|
|
|
int pk_algo;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2017-06-06 16:01:40 +02:00
|
|
|
|
/* Check compliance. */
|
2017-06-20 09:25:56 +02:00
|
|
|
|
pk_algo = gpgsm_get_key_algo_info (cl->cert, &nbits);
|
2020-07-03 15:47:55 +02:00
|
|
|
|
if (!gnupg_pk_is_compliant (opt.compliance, pk_algo, 0,
|
|
|
|
|
NULL, nbits, NULL))
|
2017-06-06 16:01:40 +02:00
|
|
|
|
{
|
2017-07-27 14:54:50 +02:00
|
|
|
|
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));
|
2017-06-06 16:01:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
2017-06-20 09:25:56 +02:00
|
|
|
|
/* Fixme: When adding ECC we need to provide the curvename and
|
|
|
|
|
* the key to gnupg_pk_is_compliant. */
|
|
|
|
|
if (compliant
|
2020-07-03 15:47:55 +02:00
|
|
|
|
&& !gnupg_pk_is_compliant (CO_DE_VS, pk_algo, 0, NULL, nbits, NULL))
|
2017-06-20 09:25:56 +02:00
|
|
|
|
compliant = 0;
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
rc = encrypt_dek (dek, cl->cert, &encval);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
2007-12-12 10:28:30 +00:00
|
|
|
|
audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, rc);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
log_error ("encryption failed for recipient no. %d: %s\n",
|
|
|
|
|
recpno, gpg_strerror (rc));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
err = ksba_cms_add_recipient (cms, cl->cert);
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
2007-12-12 10:28:30 +00:00
|
|
|
|
audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
log_error ("ksba_cms_add_recipient failed: %s\n",
|
2003-11-12 15:17:44 +00:00
|
|
|
|
gpg_strerror (err));
|
|
|
|
|
rc = err;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
xfree (encval);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
err = ksba_cms_set_enc_val (cms, recpno, encval);
|
|
|
|
|
xfree (encval);
|
2007-12-12 10:28:30 +00:00
|
|
|
|
audit_log_cert (ctrl->audit, AUDIT_ENCRYPTED_TO, cl->cert, err);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
log_error ("ksba_cms_set_enc_val failed: %s\n",
|
2003-11-12 15:17:44 +00:00
|
|
|
|
gpg_strerror (err));
|
|
|
|
|
rc = err;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2007-12-12 10:28:30 +00:00
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
2021-01-28 15:48:08 +01:00
|
|
|
|
if (compliant && gnupg_gcrypt_is_compliant (CO_DE_VS))
|
2017-06-20 09:25:56 +02:00
|
|
|
|
gpgsm_status (ctrl, STATUS_ENCRYPTION_COMPLIANCE_MODE,
|
|
|
|
|
gnupg_status_compliance_flag (CO_DE_VS));
|
2022-03-08 19:06:30 +01:00
|
|
|
|
else if (opt.require_compliance
|
|
|
|
|
&& opt.compliance == CO_DE_VS)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("operation forced to fail due to"
|
|
|
|
|
" unfulfilled compliance rules\n"));
|
|
|
|
|
gpgsm_errors_seen = 1;
|
|
|
|
|
rc = gpg_error (GPG_ERR_FORBIDDEN);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2017-06-20 09:25:56 +02:00
|
|
|
|
|
2003-12-17 17:12:14 +00:00
|
|
|
|
/* Main control loop for encryption. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
recpno = 0;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
do
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{
|
|
|
|
|
err = ksba_cms_build (cms, &stopreason);
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
2003-11-12 15:17:44 +00:00
|
|
|
|
log_debug ("ksba_cms_build failed: %s\n", gpg_strerror (err));
|
|
|
|
|
rc = err;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
while (stopreason != KSBA_SR_READY);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
if (encparm.readerror)
|
|
|
|
|
{
|
|
|
|
|
log_error ("error reading input: %s\n", strerror (encparm.readerror));
|
|
|
|
|
rc = gpg_error (gpg_err_code_from_errno (encparm.readerror));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-02-16 17:11:38 +01:00
|
|
|
|
rc = gnupg_ksba_finish_writer (b64writer);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
if (rc)
|
2003-08-05 17:11:04 +00:00
|
|
|
|
{
|
|
|
|
|
log_error ("write failed: %s\n", gpg_strerror (rc));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2007-12-12 10:28:30 +00:00
|
|
|
|
audit_log (ctrl->audit, AUDIT_ENCRYPTION_DONE);
|
2021-02-24 08:38:13 +01:00
|
|
|
|
if (!opt.quiet)
|
|
|
|
|
log_info ("encrypted data created\n");
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
ksba_cms_release (cms);
|
2017-02-16 17:11:38 +01:00
|
|
|
|
gnupg_ksba_destroy_writer (b64writer);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
ksba_reader_release (reader);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
keydb_release (kh);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
xfree (dek);
|
2010-03-08 12:22:18 +00:00
|
|
|
|
es_fclose (data_fp);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
xfree (encparm.buffer);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|