** libgnutls: Eliminate double free on wrongly formatted
certificate list. Reported by Remi Gacogne.
-** libgnutls: cryptodev code corrected.
+** libgnutls: cryptodev code corrected, updated to account
+for hashes and GCM mode.
** libgnutls: Eliminated memory leak in PCKS #11 initialization.
Report and fix by Sam Varshavchik.
noinst_LTLIBRARIES = libaccelerated.la
EXTRA_DIST = accelerated.h cryptodev.h
-libaccelerated_la_SOURCES = accelerated.c cryptodev.c
+libaccelerated_la_SOURCES = accelerated.c cryptodev.c cryptodev-gcm.c
libaccelerated_la_LIBADD =
if ASM_X86
--- /dev/null
+/*
+ * Copyright (C) 2012 Free Software Foundation, Inc.
+ *
+ * Author: Nikos Mavrogiannopoulos
+ *
+ * This file is part of GnuTLS.
+ *
+ * The GnuTLS is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <gnutls_errors.h>
+#include <gnutls_int.h>
+#include <gnutls/crypto.h>
+#include <gnutls_errors.h>
+
+#ifdef ENABLE_CRYPTODEV
+
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <crypto/cryptodev.h>
+#include <accelerated/cryptodev.h>
+
+#ifdef CIOCAUTHCRYPT
+
+#define GCM_BLOCK_SIZE 16
+
+struct cryptodev_gcm_ctx
+{
+ struct session_op sess;
+ struct crypt_auth_op cryp;
+ uint8_t iv[GCM_BLOCK_SIZE];
+ uint8_t tag[GCM_BLOCK_SIZE];
+
+ void* auth_data;
+ unsigned int auth_data_size;
+
+ int op; /* whether encryption op has been executed */
+
+ int cfd;
+};
+
+static void
+aes_gcm_deinit (void *_ctx)
+{
+ struct cryptodev_gcm_ctx *ctx = _ctx;
+
+ ioctl (ctx->cfd, CIOCFSESSION, &ctx->sess.ses);
+ gnutls_free (ctx);
+}
+
+static const int cipher_map[] = {
+ [GNUTLS_CIPHER_AES_128_GCM] = CRYPTO_AES_GCM,
+ [GNUTLS_CIPHER_AES_256_GCM] = CRYPTO_AES_GCM,
+};
+
+static int
+aes_gcm_cipher_init (gnutls_cipher_algorithm_t algorithm, void **_ctx, int enc)
+{
+ struct cryptodev_gcm_ctx *ctx;
+
+ *_ctx = gnutls_calloc (1, sizeof (struct cryptodev_gcm_ctx));
+ if (*_ctx == NULL)
+ {
+ gnutls_assert ();
+ return GNUTLS_E_MEMORY_ERROR;
+ }
+
+
+ ctx = *_ctx;
+
+ ctx->cfd = _gnutls_cryptodev_fd;
+ ctx->sess.cipher = cipher_map[algorithm];
+ ctx->cryp.iv = ctx->iv;
+
+ return 0;
+}
+
+static int
+aes_gcm_cipher_setkey (void *_ctx, const void *userkey, size_t keysize)
+{
+ struct cryptodev_gcm_ctx *ctx = _ctx;
+
+ ctx->sess.keylen = keysize;
+ ctx->sess.key = (void*)userkey;
+
+ if (ioctl (ctx->cfd, CIOCGSESSION, &ctx->sess))
+ {
+ gnutls_assert ();
+ return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
+ }
+ ctx->cryp.ses = ctx->sess.ses;
+
+ return 0;
+}
+
+static int
+aes_gcm_setiv (void *_ctx, const void *iv, size_t iv_size)
+{
+ struct cryptodev_gcm_ctx *ctx = _ctx;
+
+ if (iv_size != GCM_BLOCK_SIZE - 4)
+ return GNUTLS_E_INVALID_REQUEST;
+
+ memcpy (ctx->iv, iv, GCM_BLOCK_SIZE - 4);
+
+ ctx->cryp.iv = (void*)ctx->iv;
+
+ return 0;
+}
+
+static int
+aes_gcm_encrypt (void *_ctx, const void *src, size_t src_size,
+ void *dst, size_t dst_size)
+{
+ struct cryptodev_gcm_ctx *ctx = _ctx;
+
+ /* the GCM in kernel will place the tag after the
+ * encrypted data.
+ */
+fprintf(stderr, "dst: %u, src: %u\n", (unsigned)dst_size, (unsigned)src_size);
+ if (dst_size < src_size + GCM_BLOCK_SIZE)
+ return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
+
+ ctx->cryp.len = src_size;
+ ctx->cryp.src = (void *) src;
+ ctx->cryp.dst = dst;
+ ctx->cryp.op = COP_ENCRYPT;
+
+ ctx->cryp.auth_len = ctx->auth_data_size;
+ ctx->cryp.auth_src = ctx->auth_data;
+
+ if (ioctl (ctx->cfd, CIOCAUTHCRYPT, &ctx->cryp))
+ {
+ gnutls_assert ();
+ return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
+ }
+
+ ctx->cryp.auth_len = 0;
+ ctx->op = 1;
+ memcpy(ctx->tag, &((uint8_t*)dst)[src_size], GCM_BLOCK_SIZE);
+ return 0;
+}
+
+static int
+aes_gcm_decrypt (void *_ctx, const void *src, size_t src_size,
+ void *dst, size_t dst_size)
+{
+ struct cryptodev_gcm_ctx *ctx = _ctx;
+
+ /* the GCM in kernel will place the tag after the
+ * encrypted data.
+ */
+ ctx->cryp.len = src_size + GCM_BLOCK_SIZE;
+ ctx->cryp.src = (void *) src;
+ ctx->cryp.dst = dst;
+ ctx->cryp.op = COP_DECRYPT;
+
+ ctx->cryp.auth_len = ctx->auth_data_size;
+ ctx->cryp.auth_src = ctx->auth_data;
+
+ if (ioctl (ctx->cfd, CIOCAUTHCRYPT, &ctx->cryp))
+ {
+ gnutls_assert ();
+ return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
+ }
+
+ ctx->cryp.auth_len = 0;
+ ctx->op = 1;
+ memcpy(ctx->tag, &((uint8_t*)dst)[src_size], GCM_BLOCK_SIZE);
+ return 0;
+}
+
+static int
+aes_gcm_auth (void *_ctx, const void *src, size_t src_size)
+{
+ struct cryptodev_gcm_ctx *ctx = _ctx;
+
+ ctx->op = 0;
+ ctx->auth_data = (void*)src;
+ ctx->auth_data_size = src_size;
+
+ return 0;
+}
+
+static void
+aes_gcm_tag (void *_ctx, void *tag, size_t tagsize)
+{
+ struct cryptodev_gcm_ctx *ctx = _ctx;
+
+ if (ctx->op == 0)
+ {
+ ctx->cryp.len = 0;
+ ctx->cryp.src = NULL;
+ ctx->cryp.dst = ctx->tag;
+ ctx->cryp.op = COP_ENCRYPT;
+
+ ctx->cryp.auth_len = ctx->auth_data_size;
+ ctx->cryp.auth_src = ctx->auth_data;
+
+ if (ioctl (ctx->cfd, CIOCAUTHCRYPT, &ctx->cryp))
+ {
+ gnutls_assert ();
+ return;
+ }
+ }
+
+ memcpy(tag, ctx->tag, tagsize);
+ ctx->op = 0;
+}
+
+static const gnutls_crypto_cipher_st cipher_struct = {
+ .init = aes_gcm_cipher_init,
+ .setkey = aes_gcm_cipher_setkey,
+ .setiv = aes_gcm_setiv,
+ .encrypt = aes_gcm_encrypt,
+ .decrypt = aes_gcm_decrypt,
+ .deinit = aes_gcm_deinit,
+ .tag = aes_gcm_tag,
+ .auth = aes_gcm_auth,
+};
+
+int
+_cryptodev_register_gcm_crypto (int cfd)
+{
+ struct session_op sess;
+ uint8_t fake_key[CRYPTO_CIPHER_MAX_KEY_LEN];
+ unsigned int i;
+ int ret;
+#ifdef CIOCGSESSINFO
+ struct session_info_op siop;
+
+ memset(&siop, 0, sizeof(siop));
+#endif
+
+ memset (&sess, 0, sizeof (sess));
+
+ for (i = 0; i < sizeof (cipher_map) / sizeof (cipher_map[0]);
+ i++)
+ {
+ if (cipher_map[i] == 0)
+ continue;
+
+ /* test if a cipher is support it and if yes register it */
+ sess.cipher = cipher_map[i];
+ sess.keylen = gnutls_cipher_get_key_size (i);
+ sess.key = fake_key;
+
+ if (ioctl (cfd, CIOCGSESSION, &sess))
+ {
+ continue;
+ }
+
+#ifdef CIOCGSESSINFO
+ siop.ses = sess.ses; /* do not register ciphers that are not hw accelerated */
+ if (ioctl(cfd, CIOCGSESSINFO, &siop) == 0)
+ {
+ if (!(siop.flags & SIOP_FLAG_KERNEL_DRIVER_ONLY))
+ {
+ ioctl (cfd, CIOCFSESSION, &sess.ses);
+ continue;
+ }
+ }
+#endif
+
+ ioctl (cfd, CIOCFSESSION, &sess.ses);
+
+ _gnutls_debug_log ("/dev/crypto: registering: %s\n",
+ gnutls_cipher_get_name (i));
+ ret = gnutls_crypto_single_cipher_register (i, 90, &cipher_struct);
+ if (ret < 0)
+ {
+ gnutls_assert ();
+ return ret;
+ }
+
+ }
+
+ return 0;
+}
+
+#else /* CIOCAUTHCRYPT */
+
+int
+_cryptodev_register_gcm_crypto (int cfd)
+{
+ return 0;
+}
+
+#endif /* CIOCAUTHCRYPT */
+
+#endif /* ENABLE_CRYPTODEV */
#include <gnutls_errors.h>
#include <gnutls_int.h>
#include <gnutls/crypto.h>
-#include <accelerated/cryptodev.h>
#include <gnutls_errors.h>
#ifdef ENABLE_CRYPTODEV
#include <fcntl.h>
#include <sys/ioctl.h>
#include <crypto/cryptodev.h>
+#include <accelerated/cryptodev.h>
-#ifndef CRYPTO_CIPHER_MAX_KEY_LEN
-#define CRYPTO_CIPHER_MAX_KEY_LEN 64
-#endif
-
-#ifndef EALG_MAX_BLOCK_LEN
-#define EALG_MAX_BLOCK_LEN 16
-#endif
-
-static int cryptodev_fd = -1;
+int _gnutls_cryptodev_fd = -1;
static int register_mac_digest (int cfd);
ctx = *_ctx;
- ctx->cfd = cryptodev_fd;
+ ctx->cfd = _gnutls_cryptodev_fd;
ctx->sess.cipher = cipher;
ctx->cryp.iv = ctx->iv;
return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
}
return 0;
-
}
static void
}
- return 0;
+ return _cryptodev_register_gcm_crypto(cfd);
}
int
int ret;
/* Open the crypto device */
- cryptodev_fd = open ("/dev/crypto", O_RDWR, 0);
- if (cryptodev_fd < 0)
+ _gnutls_cryptodev_fd = open ("/dev/crypto", O_RDWR, 0);
+ if (_gnutls_cryptodev_fd < 0)
{
gnutls_assert ();
return GNUTLS_E_CRYPTODEV_DEVICE_ERROR;
{
int cfd = -1;
/* Clone file descriptor */
- if (ioctl (cryptodev_fd, CRIOGET, &cfd))
+ if (ioctl (_gnutls_cryptodev_fd, CRIOGET, &cfd))
{
gnutls_assert ();
return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
}
- close (cryptodev_fd);
- cryptodev_fd = cfd;
+ close (_gnutls_cryptodev_fd);
+ _gnutls_cryptodev_fd = cfd;
}
#endif
- ret = register_crypto (cryptodev_fd);
+ ret = register_crypto (_gnutls_cryptodev_fd);
if (ret < 0)
gnutls_assert ();
if (ret >= 0)
{
- ret = register_mac_digest (cryptodev_fd);
+ ret = register_mac_digest (_gnutls_cryptodev_fd);
if (ret < 0)
gnutls_assert ();
}
if (ret < 0)
{
gnutls_assert ();
- close (cryptodev_fd);
+ close (_gnutls_cryptodev_fd);
}
return ret;
void
_gnutls_cryptodev_deinit (void)
{
- if (cryptodev_fd != -1) close (cryptodev_fd);
+ if (_gnutls_cryptodev_fd != -1) close (_gnutls_cryptodev_fd);
}
/* MAC and digest stuff */
ctx = *_ctx;
- ctx->cfd = cryptodev_fd;
+ ctx->cfd = _gnutls_cryptodev_fd;
ctx->sess.mac = mac;
int ret;
memset(&ctx, 0, sizeof(ctx));
- ctx.cfd = cryptodev_fd;
+ ctx.cfd = _gnutls_cryptodev_fd;
ctx.sess.mac = gnutls_mac_map[algo];
ctx.sess.mackeylen = key_size;
ret = ioctl (ctx.cfd, CIOCCRYPT, &ctx.cryp);
- ioctl (cryptodev_fd, CIOCFSESSION, &ctx.sess.ses);
+ ioctl (_gnutls_cryptodev_fd, CIOCFSESSION, &ctx.sess.ses);
if (ret != 0)
return gnutls_assert_val(GNUTLS_E_CRYPTODEV_IOCTL_ERROR);
ctx = *_ctx;
- ctx->cfd = cryptodev_fd;
+ ctx->cfd = _gnutls_cryptodev_fd;
ctx->sess.mac = dig;
if (ioctl (ctx->cfd, CIOCGSESSION, &ctx->sess))
int ret;
memset(&ctx, 0, sizeof(ctx));
- ctx.cfd = cryptodev_fd;
+ ctx.cfd = _gnutls_cryptodev_fd;
ctx.sess.mac = gnutls_digest_map[algo];
if (ioctl (ctx.cfd, CIOCGSESSION, &ctx.sess))
ret = ioctl (ctx.cfd, CIOCCRYPT, &ctx.cryp);
- ioctl (cryptodev_fd, CIOCFSESSION, &ctx.sess.ses);
+ ioctl (_gnutls_cryptodev_fd, CIOCFSESSION, &ctx.sess.ses);
if (ret != 0)
return gnutls_assert_val(GNUTLS_E_CRYPTODEV_IOCTL_ERROR);
+extern int _gnutls_cryptodev_fd;
+
+#ifndef CRYPTO_CIPHER_MAX_KEY_LEN
+#define CRYPTO_CIPHER_MAX_KEY_LEN 64
+#endif
+
+#ifndef EALG_MAX_BLOCK_LEN
+#define EALG_MAX_BLOCK_LEN 16
+#endif
+
void _gnutls_cryptodev_deinit (void);
int _gnutls_cryptodev_init (void);
+int _cryptodev_register_gcm_crypto (int cfd);
/* Actual encryption (inplace).
*/
ret =
- _gnutls_auth_cipher_encrypt_tag (¶ms->write.cipher_state,
- cipher_data, length_to_encrypt, tag_ptr, tag_size, compressed->size);
+ _gnutls_auth_cipher_encrypt2_tag (¶ms->write.cipher_state,
+ cipher_data, length_to_encrypt,
+ cipher_data, cipher_size,
+ tag_ptr, tag_size, compressed->size);
if (ret < 0)
return gnutls_assert_val(ret);
return gnutls_assert_val(ret);
if ((ret =
- _gnutls_auth_cipher_decrypt (¶ms->read.cipher_state,
- ciphertext->data, length_to_decrypt)) < 0)
+ _gnutls_auth_cipher_decrypt2 (¶ms->read.cipher_state,
+ ciphertext->data, length_to_decrypt,
+ ciphertext->data, ciphertext->size)) < 0)
return gnutls_assert_val(ret);
break;
return _gnutls_cipher_is_aead(&handle->cipher);
}
-#define _gnutls_auth_cipher_encrypt_tag(x,y,z,t,s,a) _gnutls_auth_cipher_encrypt2_tag(x,y,z,y,z,t,s,a)
-#define _gnutls_auth_cipher_decrypt(x,y,z) _gnutls_auth_cipher_decrypt2(x,y,z,y,z)
-
void _gnutls_auth_cipher_deinit (auth_cipher_hd_st * handle);
/* Functions that are record layer specific, are included in this file.
*/
+/* allocate this many bytes more when encrypting or decrypting, to
+ * compensate for broken backends such as cryptodev.
+ */
+#define CIPHER_SLACK_SIZE 32
+
#include "gnutls_int.h"
#include "gnutls_errors.h"
#include "debug.h"
}
else
{
-
/* now proceed to packet encryption
*/
- cipher_size = send_data_size + MAX_RECORD_OVERHEAD;
+ cipher_size = send_data_size + MAX_RECORD_OVERHEAD + CIPHER_SLACK_SIZE;
bufel = _mbuffer_alloc (cipher_size, cipher_size);
if (bufel == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
/* We allocate the maximum possible to allow few compressed bytes to expand to a
* full record.
*/
- decrypted = _mbuffer_alloc(MAX_RECORD_RECV_SIZE(session), MAX_RECORD_RECV_SIZE(session));
+ decrypted = _mbuffer_alloc(MAX_RECORD_RECV_SIZE(session),
+ MAX_RECORD_RECV_SIZE(session));
if (decrypted == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
};
struct aes_gcm_vectors_st aes_gcm_vectors[] = {
+#if 0
{
.key = (void*)
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
.iv = (void*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
.tag = (void*)
"\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4\xe7\x45\x5a"},
+#endif
{
.key = (void*)
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
}
ret = gnutls_cipher_encrypt2 (hd, aes_vectors[i].plaintext, 16,
- tmp, 16);
+ tmp, sizeof(tmp));
if (ret < 0)
{
fprintf (stderr, "%d: AES test %d failed\n", __LINE__, i);
}
ret = gnutls_cipher_decrypt2 (hd, aes_vectors[i].ciphertext, 16,
- tmp, 16);
+ tmp, sizeof(tmp));
if (ret < 0)
{
fprintf (stderr, "%d: AES test %d failed\n", __LINE__, i);
aes_gcm_vectors[i].plaintext,
aes_gcm_vectors[i].
plaintext_size, tmp,
- aes_gcm_vectors[i].
- plaintext_size);
+ sizeof(tmp));
if (ret < 0)
{
- fprintf (stderr, "%d: AES-GCM test %d failed\n",
- __LINE__, i);
+ fprintf (stderr, "%d: AES-GCM test %d failed: %s\n",
+ __LINE__, i, gnutls_strerror(ret));
return 1;
}
}
projects / thirdparty / gnutls.git / commitdiff
