/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 *

 */

#include <sys/types.h>

#include <sys/stat.h>

#include <string.h>

#include <fcntl.h>

#include <pthread.h>

#include <errno.h>

#include <cryptoutil.h>

#include <sys/crypto/ioctl.h>

#include <sys/crypto/api.h>

#include <openssl/bio.h>

#include <openssl/aes.h>

#include <openssl/engine.h>

#include <security/cryptoki.h>

#define	DEVCRYPTO_LIB_NAME "devcrypto engine"

#include "e_devcrypto_err.c"

/* DEVCRYPTO CONTEXT */

typedef struct devcrypto_ctx {

	uint_t session_id;

} devcrypto_ctx_t;

/* Index for the supported ciphers */

typedef enum {

	DEV_DES_CBC,

	DEV_DES3_CBC,

	DEV_DES_ECB,

	DEV_DES3_ECB,

	DEV_RC4,

	DEV_AES_128_CBC,

	DEV_AES_192_CBC,

	DEV_AES_256_CBC,

	DEV_AES_128_ECB,

	DEV_AES_192_ECB,

	DEV_AES_256_ECB,

	DEV_BLOWFISH_CBC,

	DEV_AES_128_CTR,

	DEV_AES_192_CTR,

	DEV_AES_256_CTR,

	DEV_CIPHER_MAX

} DEV_CIPHER_ID;

typedef struct devcrypto_cipher {

	DEV_CIPHER_ID		id;

	int			nid;

	int			iv_len;

	int			min_key_len;

	int			max_key_len;

	CK_KEY_TYPE		key_type;

	CK_MECHANISM_TYPE	mech_type;

	unsigned long		flags;

	crypto_mech_type_t	pn_internal_number;

} devcrypto_cipher_t;

/* Constants used when creating the ENGINE */

static const char *ENGINE_DEVCRYPTO_ID = "devcrypto";

static const char *ENGINE_DEVCRYPTO_NAME = "/dev/crypto engine support";

static const char *CRYPTO_DEVICE = "/dev/crypto";

/* static variables */

static int kernel_fd = -1;

static int kernel_fd_ref = 0;

static int slot_count = 0;

static CK_SLOT_ID *kernel_provider_id = NULL;

static int cipher_count = 0;

static int *cipher_nids = NULL;

pthread_mutex_t *kernel_fd_lock;

/*

 * Cipher Table for all supported symmetric ciphers.

 */

static devcrypto_cipher_t cipher_table[] = {

	/* id,			nid,		iv_len, min_, max_key_len, */

		/* key_type,	mech_type, flags, pn_internal_number */

	{ DEV_DES_CBC,		NID_des_cbc,		8,	 8,   8,

		CKK_DES,	CKM_DES_CBC, 0, CRYPTO_MECH_INVALID},

	{ DEV_DES3_CBC,		NID_des_ede3_cbc,	8,	24,  24,

		CKK_DES3,	CKM_DES3_CBC, 0, CRYPTO_MECH_INVALID},

	{ DEV_DES_ECB,		NID_des_ecb,		0,	 8,   8,

		CKK_DES,	CKM_DES_ECB, 0, CRYPTO_MECH_INVALID},

	{ DEV_DES3_ECB,		NID_des_ede3_ecb,	0,	24,  24,

		CKK_DES3,	CKM_DES3_ECB, 0, CRYPTO_MECH_INVALID},

	{ DEV_RC4,		NID_rc4,		0,	16, 256,

		CKK_RC4,	CKM_RC4, 0, CRYPTO_MECH_INVALID},

	{ DEV_AES_128_CBC,	NID_aes_128_cbc,	16,	16,  16,

		CKK_AES,	CKM_AES_CBC, 0, CRYPTO_MECH_INVALID},

	{ DEV_AES_192_CBC,	NID_aes_192_cbc,	16,	24,  24,

		CKK_AES,	CKM_AES_CBC, 0, CRYPTO_MECH_INVALID},

	{ DEV_AES_256_CBC,	NID_aes_256_cbc,	16,	32,  32,

		CKK_AES,	CKM_AES_CBC, 0, CRYPTO_MECH_INVALID},

	{ DEV_AES_128_ECB,	NID_aes_128_ecb,	0,	16,  16,

		CKK_AES,	CKM_AES_ECB, 0, CRYPTO_MECH_INVALID},

	{ DEV_AES_192_ECB,	NID_aes_192_ecb,	0,	24,  24,

		CKK_AES,	CKM_AES_ECB, 0, CRYPTO_MECH_INVALID},

	{ DEV_AES_256_ECB,	NID_aes_256_ecb,	0,	32,  32,

		CKK_AES,	CKM_AES_ECB, 0, CRYPTO_MECH_INVALID},

	{ DEV_BLOWFISH_CBC,	NID_bf_cbc,		8,	16,  16,

		CKK_BLOWFISH,	CKM_BLOWFISH_CBC, 0, CRYPTO_MECH_INVALID},

		CKK_AES,	CKM_AES_CTR, EVP_CIPH_NO_PADDING,

		CRYPTO_MECH_INVALID},

		CKK_AES,	CKM_AES_CTR, EVP_CIPH_NO_PADDING,

		CRYPTO_MECH_INVALID},

		CKK_AES,	CKM_AES_CTR, EVP_CIPH_NO_PADDING,

		CRYPTO_MECH_INVALID},

	};

/* Formal declaration for functions in EVP_CIPHER structure */

static int devcrypto_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,

    const unsigned char *iv, int enc);

static int devcrypto_cipher_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,

    const unsigned char *in, size_t inl);

static int devcrypto_cipher_cleanup(EVP_CIPHER_CTX *ctx);

/*

 * Cipher Algorithms

 *

 * OpenSSL's libcrypto EVP stuff. This is how this engine gets wired to EVP.

 * EVP_CIPHER is defined in evp.h.  To maintain binary compatibility the

 * definition cannot be modified.

 * Stuff specific to the devcrypto engine is kept in devcrypto_ctx_t, which is

 * pointed to by cipher_data or md_data.

 *

 * Fields: nid, block_size, key_len, iv_len, flags,

 *	init(), do_cipher(), cleanup(),

 *	ctx_size,

 *	set_asn1_parameters(), get_asn1_parameters(), ctrl(), app_data

 */

static const EVP_CIPHER dev_des_cbc = {

	NID_des_cbc,

	8, 8, 8,

	EVP_CIPH_CBC_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	EVP_CIPHER_set_asn1_iv,

	EVP_CIPHER_get_asn1_iv,

	NULL

};

static const EVP_CIPHER dev_3des_cbc = {

	NID_des_ede3_cbc,

	8, 24, 8,

	EVP_CIPH_CBC_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	EVP_CIPHER_set_asn1_iv,

	EVP_CIPHER_get_asn1_iv,

	NULL

};

/*

 * ECB modes don't use an Initial Vector, therefore set_asn1_parameters and

 * get_asn1_parameters fields are set to NULL.

 */

static const EVP_CIPHER dev_des_ecb = {

	NID_des_ecb,

	8, 8, 8,

	EVP_CIPH_ECB_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	NULL,

	NULL,

	NULL

};

static const EVP_CIPHER dev_3des_ecb = {

	NID_des_ede3_ecb,

	8, 24, 8,

	EVP_CIPH_ECB_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	NULL,

	NULL,

	NULL

};

static const EVP_CIPHER dev_rc4 = {

	NID_rc4,

	1, 16, 0,

	EVP_CIPH_VARIABLE_LENGTH,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	NULL,

	NULL,

	NULL

};

static const EVP_CIPHER dev_aes_128_cbc = {

	NID_aes_128_cbc,

	16, 16, 16,

	EVP_CIPH_CBC_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	EVP_CIPHER_set_asn1_iv,

	EVP_CIPHER_get_asn1_iv,

	NULL

};

static const EVP_CIPHER dev_aes_192_cbc = {

	NID_aes_192_cbc,

	16, 24, 16,

	EVP_CIPH_CBC_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	EVP_CIPHER_set_asn1_iv,

	EVP_CIPHER_get_asn1_iv,

	NULL

};

static const EVP_CIPHER dev_aes_256_cbc = {

	NID_aes_256_cbc,

	16, 32, 16,

	EVP_CIPH_CBC_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	EVP_CIPHER_set_asn1_iv,

	EVP_CIPHER_get_asn1_iv,

	NULL

};

/*

 * ECB modes don't use IV, therefore set_asn1_parameters and

 * get_asn1_parameters are set to NULL.

 */

static const EVP_CIPHER dev_aes_128_ecb = {

	NID_aes_128_ecb,

	16, 16, 0,

	EVP_CIPH_ECB_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	NULL,

	NULL,

	NULL

};

static const EVP_CIPHER dev_aes_192_ecb = {

	NID_aes_192_ecb,

	16, 24, 0,

	EVP_CIPH_ECB_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	NULL,

	NULL,

	NULL

};

static const EVP_CIPHER dev_aes_256_ecb = {

	NID_aes_256_ecb,

	16, 32, 0,

	EVP_CIPH_ECB_MODE,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	NULL,

	NULL,

	NULL

};

static const EVP_CIPHER dev_bf_cbc = {

	NID_bf_cbc,

	8, 16, 8,

	EVP_CIPH_VARIABLE_LENGTH,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	EVP_CIPHER_set_asn1_iv,

	EVP_CIPHER_get_asn1_iv,

	NULL

};

/*

 * NID_undef's will be changed for AES counter mode, as soon they are created.

 */

static EVP_CIPHER dev_aes_128_ctr = {

	16, 16, 16,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	EVP_CIPHER_set_asn1_iv,

	EVP_CIPHER_get_asn1_iv,

	NULL

};

static EVP_CIPHER dev_aes_192_ctr = {

	16, 24, 16,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	EVP_CIPHER_set_asn1_iv,

	EVP_CIPHER_get_asn1_iv,

	NULL

};

static EVP_CIPHER dev_aes_256_ctr = {

	16, 32, 16,

	devcrypto_cipher_init,

	devcrypto_cipher_do_cipher,

	devcrypto_cipher_cleanup,

	sizeof (devcrypto_ctx_t),

	EVP_CIPHER_set_asn1_iv,

	EVP_CIPHER_get_asn1_iv,

	NULL

};

/*

 * Open the /dev/crypto device

 */

static int

devcrypto_open(void)

{

	int fd = -1;

	if (kernel_fd != -1) {  /* already open */

		(void) pthread_mutex_lock(kernel_fd_lock);

		kernel_fd_ref++;

		(void) pthread_mutex_unlock(kernel_fd_lock);

		return (1);

	}

	(void) pthread_mutex_lock(kernel_fd_lock);

	fd = open(CRYPTO_DEVICE, O_RDWR);

	if (fd == -1) {

#ifdef DEBUG

		(void) fprintf(stderr,

		    "libdevcrypto: open /dev/crypto failed, errno=%x\n",

		    errno);

#endif

		(void) pthread_mutex_unlock(kernel_fd_lock);

		return (0);

	}

	if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) {

#ifdef DEBUG

		(void) fprintf(stderr, "libdevcrypto: failed to fcntl\n");

#endif

		(void) close(fd);

		(void) pthread_mutex_unlock(kernel_fd_lock);

		return (0);

	}

	kernel_fd = fd;

	kernel_fd_ref++;

	(void) pthread_mutex_unlock(kernel_fd_lock);

	return (1);

}

/*

 * This function gets the total number of hardware providers presented in

 * the system first.  If there is any hardware providers, then it will get

 * the kernel provider id for each hardware slot also.

 */

static int

devcrypto_get_slot_info(void)

{

	crypto_get_provider_list_t *pl = NULL;

	int ret = 1;

	int r;

	int i;

	/* Already have the information */

	if (kernel_provider_id != NULL)

		return (1);

	/* Find out how many hardware slots are presented. */

	pl = OPENSSL_malloc(sizeof (crypto_get_provider_list_t));

	if (pl == NULL)

		return (0);

	pl->pl_count = 0;

	while ((r = ioctl(kernel_fd, CRYPTO_GET_PROVIDER_LIST, pl)) < 0) {

		if (errno != EINTR)

			break;

	}

	if (r < 0 || pl->pl_return_value != CRYPTO_SUCCESS) {

#ifdef DEBUG

		(void) fprintf(stderr, "libdevcrypto:CRYPTO_GET_PROVIDER_LIST:"

		    "ret (r) = 0x%x, (rv) = 0x%x\n", r,  pl->pl_return_value);

#endif /* DEBUG */

		ret = 0;

		goto out;

	}

	slot_count = pl->pl_count;

	if (slot_count == 0) {

#ifdef DEBUG

		(void) fprintf(stderr, "libdevcrypto: no hw providers\n");

#endif /* DEBUG */

		ret = 0;

		goto out;

	}

	/* Get the provider ID for each slot from kernel and save it */

	kernel_provider_id = OPENSSL_malloc(sizeof (CK_SLOT_ID) * slot_count);

	if (kernel_provider_id == NULL) {

		ret = 0;

		goto out;

	}

	(void) OPENSSL_free(pl);

	pl = OPENSSL_malloc(slot_count * sizeof (crypto_get_provider_list_t));

	if (pl == NULL) {

		ret = 0;

		goto out;

	}

	pl->pl_count = slot_count;

	while ((r = ioctl(kernel_fd, CRYPTO_GET_PROVIDER_LIST, pl)) < 0) {

		if (errno != EINTR)

			break;

	}

	if (r < 0 || (pl->pl_return_value != CRYPTO_SUCCESS)) {

#ifdef DEBUG

		(void) fprintf(stderr, "libdevcrypto:CRYPTO_GET_PROVIDER_LIST:"

		    "ret (r) = 0x%x, (rv) = 0x%x\n", r,  pl->pl_return_value);

#endif /* DEBUG */

		ret = 0;

		goto out;

	}

	for (i = 0; i < slot_count; i++) {

		kernel_provider_id[i] = pl->pl_list[i].pe_provider_id;

#ifdef DEBUG

		(void) fprintf(stderr, "libdevcrypto: i = %d, "

		    "kernel_provider_id = %d\n", i, kernel_provider_id[i]);

#endif /* DEBUG */

	}

out:

	if (pl != NULL)

		(void) OPENSSL_free(pl);

	if (ret == 0 && kernel_provider_id != NULL) {

		(void) OPENSSL_free(kernel_provider_id);

		kernel_provider_id = NULL;

	}

	return (ret);

}

/*

 * This function checks if the "nid" is already in the nid list.

 */

static int

nid_in_list(int nid, int *nid_list, int count)

{

	int i = 0;

	if (nid_list == NULL || count <= 0)

		return (0);

	while (i < count) {

		if (nid == nid_list[i])

			break;

		i++;

	}

	return (i < count ? 1 : 0);

}

/*