githubmirror/gnutls

lib/accelerated/cryptodev.c
508 строк11 KB
Daiki Ueno
build: re-indent code
24 апр 2023, 06:45
24 апр 2023, 06:45aa5950a
/*
 * Copyright (C) 2009-2010, 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 2.1 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 <https://www.gnu.org/licenses/>.
 *
 */

#include "errors.h"
#include "gnutls_int.h"
#include <gnutls/crypto.h>
#include "errors.h"
#include <accelerated/cryptodev.h>

#ifdef ENABLE_CRYPTODEV

#include <assert.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <crypto/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

int _gnutls_cryptodev_fd = -1;

static int register_mac_digest(int cfd);

struct cryptodev_ctx {
	struct session_op sess;
	struct crypt_op cryp;
	uint8_t iv[EALG_MAX_BLOCK_LEN];

	int cfd;
};

static const int gnutls_cipher_map[] = {
	[GNUTLS_CIPHER_AES_128_CBC] = CRYPTO_AES_CBC,
	[GNUTLS_CIPHER_AES_192_CBC] = CRYPTO_AES_CBC,
	[GNUTLS_CIPHER_AES_256_CBC] = CRYPTO_AES_CBC,
	[GNUTLS_CIPHER_3DES_CBC] = CRYPTO_3DES_CBC,
	[GNUTLS_CIPHER_CAMELLIA_128_CBC] = CRYPTO_CAMELLIA_CBC,
	[GNUTLS_CIPHER_CAMELLIA_192_CBC] = CRYPTO_CAMELLIA_CBC,
	[GNUTLS_CIPHER_CAMELLIA_256_CBC] = CRYPTO_CAMELLIA_CBC,
	[GNUTLS_CIPHER_DES_CBC] = CRYPTO_DES_CBC,
};

static int cryptodev_cipher_init(gnutls_cipher_algorithm_t algorithm,
				 void **_ctx, int enc)
{
	struct cryptodev_ctx *ctx;
	int cipher = gnutls_cipher_map[algorithm];

	*_ctx = gnutls_calloc(1, sizeof(struct cryptodev_ctx));
	if (*_ctx == NULL) {
		gnutls_assert();
		return GNUTLS_E_MEMORY_ERROR;
	}

	ctx = *_ctx;

	ctx->cfd = _gnutls_cryptodev_fd;
	ctx->sess.cipher = cipher;
	ctx->cryp.iv = ctx->iv;

	return 0;
}

static int cryptodev_cipher_setkey(void *_ctx, const void *key, size_t keysize)
{
	struct cryptodev_ctx *ctx = _ctx;

	CHECK_AES_KEYSIZE(keysize);

	ctx->sess.keylen = keysize;
	ctx->sess.key = (void *)key;

	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 cryptodev_setiv(void *_ctx, const void *iv, size_t iv_size)
{
	struct cryptodev_ctx *ctx = _ctx;

	if (iv_size > EALG_MAX_BLOCK_LEN)
		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	memcpy(ctx->iv, iv, iv_size);

	return 0;
}

static int cryptodev_encrypt(void *_ctx, const void *src, size_t src_size,
			     void *dst, size_t dst_size)
{
	struct cryptodev_ctx *ctx = _ctx;
	ctx->cryp.len = src_size;
	ctx->cryp.src = (void *)src;
	ctx->cryp.dst = dst;
	ctx->cryp.op = COP_ENCRYPT;
	ctx->cryp.flags = COP_FLAG_WRITE_IV;

	if (unlikely(dst_size < src_size)) {
		gnutls_assert();
		return GNUTLS_E_SHORT_MEMORY_BUFFER;
	}

	if (ioctl(ctx->cfd, CIOCCRYPT, &ctx->cryp)) {
		gnutls_assert();
		return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
	}

	return 0;
}

static int cryptodev_decrypt(void *_ctx, const void *src, size_t src_size,
			     void *dst, size_t dst_size)
{
	struct cryptodev_ctx *ctx = _ctx;

	ctx->cryp.len = src_size;
	ctx->cryp.src = (void *)src;
	ctx->cryp.dst = dst;
	ctx->cryp.op = COP_DECRYPT;
	ctx->cryp.flags = COP_FLAG_WRITE_IV;

	if (unlikely(dst_size < src_size)) {
		gnutls_assert();
		return GNUTLS_E_SHORT_MEMORY_BUFFER;
	}

	if (ioctl(ctx->cfd, CIOCCRYPT, &ctx->cryp)) {
		gnutls_assert();
		return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
	}

	return 0;
}

static void cryptodev_deinit(void *_ctx)
{
	struct cryptodev_ctx *ctx = _ctx;

	ioctl(ctx->cfd, CIOCFSESSION, &ctx->sess.ses);
	gnutls_free(ctx);
}

static const gnutls_crypto_cipher_st cipher_struct = {
	.init = cryptodev_cipher_init,
	.setkey = cryptodev_cipher_setkey,
	.setiv = cryptodev_setiv,
	.encrypt = cryptodev_encrypt,
	.decrypt = cryptodev_decrypt,
	.deinit = cryptodev_deinit,
};

static int register_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;
#endif

	memset(&sess, 0, sizeof(sess));

	for (i = 0;
	     i < sizeof(gnutls_cipher_map) / sizeof(gnutls_cipher_map[0]);
	     i++) {
		if (gnutls_cipher_map[i] == 0)
			continue;

		/* test if a cipher is supported and if yes register it */
		sess.cipher = gnutls_cipher_map[i];
		sess.keylen = gnutls_cipher_get_key_size(i);
		sess.key = fake_key;

		if (ioctl(cfd, CIOCGSESSION, &sess)) {
			continue;
		}
#ifdef CIOCGSESSINFO
		memset(&siop, 0, sizeof(siop));

		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, 0);
		if (ret < 0) {
			gnutls_assert();
			return ret;
		}
	}

#ifdef CIOCAUTHCRYPT
	return _cryptodev_register_gcm_crypto(cfd);
#else
	return 0;
#endif
}

int _gnutls_cryptodev_init(void)
{
	int ret;

	/* Open the crypto device */
	_gnutls_cryptodev_fd = open("/dev/crypto", O_RDWR, 0);
	if (_gnutls_cryptodev_fd < 0) {
		gnutls_assert();
		return GNUTLS_E_CRYPTODEV_DEVICE_ERROR;
	}
#ifndef CRIOGET_NOT_NEEDED
	{
		int cfd = -1;
		/* Clone file descriptor */
		if (ioctl(_gnutls_cryptodev_fd, CRIOGET, &cfd)) {
			gnutls_assert();
			return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
		}

		/* Set close-on-exec (not really needed here) */
		if (fcntl(cfd, F_SETFD, 1) == -1) {
			gnutls_assert();
			return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
		}

		close(_gnutls_cryptodev_fd);
		_gnutls_cryptodev_fd = cfd;
	}
#endif

	ret = register_crypto(_gnutls_cryptodev_fd);
	if (ret < 0)
		gnutls_assert();

	if (ret >= 0) {
		ret = register_mac_digest(_gnutls_cryptodev_fd);
		if (ret < 0)
			gnutls_assert();
	}

	if (ret < 0) {
		gnutls_assert();
		close(_gnutls_cryptodev_fd);
	}

	return ret;
}

void _gnutls_cryptodev_deinit(void)
{
	if (_gnutls_cryptodev_fd != -1)
		close(_gnutls_cryptodev_fd);
}

/* MAC and digest stuff */

/* if we are using linux /dev/crypto
 */
#if defined(COP_FLAG_UPDATE) && defined(COP_FLAG_RESET)

static const int gnutls_mac_map[] = {
	[GNUTLS_MAC_MD5] = CRYPTO_MD5_HMAC,
	[GNUTLS_MAC_SHA1] = CRYPTO_SHA1_HMAC,
	[GNUTLS_MAC_SHA256] = CRYPTO_SHA2_256_HMAC,
	[GNUTLS_MAC_SHA384] = CRYPTO_SHA2_384_HMAC,
	[GNUTLS_MAC_SHA512] = CRYPTO_SHA2_512_HMAC,
};

static int cryptodev_mac_fast(gnutls_mac_algorithm_t algo, const void *nonce,
			      size_t nonce_size, const void *key,
			      size_t key_size, const void *text,
			      size_t text_size, void *digest)
{
	struct cryptodev_ctx ctx;
	int ret;

	assert(nonce_size == 0);

	memset(&ctx, 0, sizeof(ctx));
	ctx.cfd = _gnutls_cryptodev_fd;
	ctx.sess.mac = gnutls_mac_map[algo];

	ctx.sess.mackeylen = key_size;
	ctx.sess.mackey = (void *)key;

	if (ioctl(ctx.cfd, CIOCGSESSION, &ctx.sess))
		return gnutls_assert_val(GNUTLS_E_CRYPTODEV_IOCTL_ERROR);

	ctx.cryp.ses = ctx.sess.ses;

	ctx.cryp.len = text_size;
	ctx.cryp.src = (void *)text;
	ctx.cryp.dst = NULL;
	ctx.cryp.op = COP_ENCRYPT;
	ctx.cryp.mac = digest;

	ret = ioctl(ctx.cfd, CIOCCRYPT, &ctx.cryp);

	ioctl(_gnutls_cryptodev_fd, CIOCFSESSION, &ctx.sess.ses);
	if (ret != 0)
		return gnutls_assert_val(GNUTLS_E_CRYPTODEV_IOCTL_ERROR);

	return 0;
}

#define cryptodev_mac_deinit cryptodev_deinit

static const gnutls_crypto_mac_st mac_struct = { .init = NULL,
						 .setkey = NULL,
						 .setnonce = NULL,
						 .hash = NULL,
						 .output = NULL,
						 .deinit = NULL,
						 .fast = cryptodev_mac_fast };

/* Digest algorithms */

static const int gnutls_digest_map[] = {
	[GNUTLS_DIG_MD5] = CRYPTO_MD5,
	[GNUTLS_DIG_SHA1] = CRYPTO_SHA1,
	[GNUTLS_DIG_SHA256] = CRYPTO_SHA2_256,
	[GNUTLS_DIG_SHA384] = CRYPTO_SHA2_384,
	[GNUTLS_DIG_SHA512] = CRYPTO_SHA2_512,
};

static int cryptodev_digest_fast(gnutls_digest_algorithm_t algo,
				 const void *text, size_t text_size,
				 void *digest)
{
	struct cryptodev_ctx ctx;
	int ret;

	memset(&ctx, 0, sizeof(ctx));
	ctx.cfd = _gnutls_cryptodev_fd;
	ctx.sess.mac = gnutls_digest_map[algo];

	if (ioctl(ctx.cfd, CIOCGSESSION, &ctx.sess))
		return gnutls_assert_val(GNUTLS_E_CRYPTODEV_IOCTL_ERROR);

	ctx.cryp.ses = ctx.sess.ses;

	ctx.cryp.len = text_size;
	ctx.cryp.src = (void *)text;
	ctx.cryp.dst = NULL;
	ctx.cryp.op = COP_ENCRYPT;
	ctx.cryp.mac = digest;

	ret = ioctl(ctx.cfd, CIOCCRYPT, &ctx.cryp);

	ioctl(_gnutls_cryptodev_fd, CIOCFSESSION, &ctx.sess.ses);
	if (ret != 0)
		return gnutls_assert_val(GNUTLS_E_CRYPTODEV_IOCTL_ERROR);

	return 0;
}

static const gnutls_crypto_digest_st digest_struct = {
	.init = NULL,
	.hash = NULL,
	.output = NULL,
	.deinit = NULL,
	.fast = cryptodev_digest_fast
};

static int register_mac_digest(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;
#endif

	memset(&sess, 0, sizeof(sess));
	for (i = 0; i < sizeof(gnutls_mac_map) / sizeof(gnutls_mac_map[0]);
	     i++) {
		if (gnutls_mac_map[i] == 0)
			continue;

		sess.mac = gnutls_mac_map[i];
		sess.mackeylen = 8;
		sess.mackey = fake_key;

		if (ioctl(cfd, CIOCGSESSION, &sess)) {
			continue;
		}
#ifdef CIOCGSESSINFO
		memset(&siop, 0, sizeof(siop));

		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
		_gnutls_debug_log("/dev/crypto: registering: HMAC-%s\n",
				  gnutls_mac_get_name(i));

		ioctl(cfd, CIOCFSESSION, &sess.ses);

		ret = gnutls_crypto_single_mac_register(i, 90, &mac_struct, 0);
		if (ret < 0) {
			gnutls_assert();
			return ret;
		}
	}

	memset(&sess, 0, sizeof(sess));
	for (i = 0;
	     i < sizeof(gnutls_digest_map) / sizeof(gnutls_digest_map[0]);
	     i++) {
		if (gnutls_digest_map[i] == 0)
			continue;

		sess.mac = gnutls_digest_map[i];

		if (ioctl(cfd, CIOCGSESSION, &sess)) {
			continue;
		}
#ifdef CIOCGSESSINFO
		memset(&siop, 0, sizeof(siop));

		siop.ses = sess.ses;
		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_mac_get_name(i));
		ret = gnutls_crypto_single_digest_register(i, 90,
							   &digest_struct, 0);
		if (ret < 0) {
			gnutls_assert();
			return ret;
		}
	}

	return 0;
}

#else
static int register_mac_digest(int cfd)
{
	return 0;
}

#endif /* defined(COP_FLAG_UPDATE) */

#else /* ENABLE_CRYPTODEV */
int _gnutls_cryptodev_init(void)
{
	return 0;
}

void _gnutls_cryptodev_deinit(void)
{
	return;
}
#endif /* ENABLE_CRYPTODEV */