/*

 * 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

 *

 * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.

 */

#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;

	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;

/*

 * NIDs for AES counter mode. They will be defined during the engine

 * initialization.

 */

static int NID_aes_128_ctr = NID_undef;

static int NID_aes_192_ctr = NID_undef;

static int NID_aes_256_ctr = NID_undef;

/*

 * Cipher Table for all supported symmetric ciphers.

 */

static devcrypto_cipher_t cipher_table[] = {

	{ DEV_DES_CBC,		NID_des_cbc,		8,	 8,   8,

		CKK_DES,	CKM_DES_CBC, CRYPTO_MECH_INVALID},

	{ DEV_DES3_CBC,		NID_des_ede3_cbc,	8,	24,  24,

		CKK_DES3,	CKM_DES3_CBC, CRYPTO_MECH_INVALID},

	{ DEV_DES_ECB,		NID_des_ecb,		0,	 8,   8,

		CKK_DES,	CKM_DES_ECB, CRYPTO_MECH_INVALID},

	{ DEV_DES3_ECB,		NID_des_ede3_ecb,	0,	24,  24,

		CKK_DES3,	CKM_DES3_ECB, CRYPTO_MECH_INVALID},

	{ DEV_RC4,		NID_rc4,		0,	16, 256,

		CKK_RC4,	CKM_RC4, CRYPTO_MECH_INVALID},

	{ DEV_AES_128_CBC,	NID_aes_128_cbc,	16,	16,  16,

		CKK_AES,	CKM_AES_CBC, CRYPTO_MECH_INVALID},

	{ DEV_AES_192_CBC,	NID_aes_192_cbc,	16,	24,  24,

		CKK_AES,	CKM_AES_CBC, CRYPTO_MECH_INVALID},

	{ DEV_AES_256_CBC,	NID_aes_256_cbc,	16,	32,  32,

		CKK_AES,	CKM_AES_CBC, CRYPTO_MECH_INVALID},

	{ DEV_AES_128_ECB,	NID_aes_128_ecb,	0,	16,  16,

		CKK_AES,	CKM_AES_ECB, CRYPTO_MECH_INVALID},

	{ DEV_AES_192_ECB,	NID_aes_192_ecb,	0,	24,  24,

		CKK_AES,	CKM_AES_ECB, CRYPTO_MECH_INVALID},

	{ DEV_AES_256_ECB,	NID_aes_256_ecb,	0,	32,  32,

		CKK_AES,	CKM_AES_ECB, CRYPTO_MECH_INVALID},

	{ DEV_BLOWFISH_CBC,	NID_bf_cbc,		8,	16,  16,

		CKK_BLOWFISH,	CKM_BLOWFISH_CBC, CRYPTO_MECH_INVALID},

	/*

	 * For the following 3 AES counter mode entries, we don't know the

	 * NIDs until the engine is initialized

	 */

	{ DEV_AES_128_CTR,	NID_undef,		16,	16,  16,

		CKK_AES,	CKM_AES_CTR, CRYPTO_MECH_INVALID},

	{ DEV_AES_192_CTR,	NID_undef,		16,	24,  24,

		CKK_AES,	CKM_AES_CTR, CRYPTO_MECH_INVALID},

	{ DEV_AES_256_CTR,	NID_undef,		16,	32,  32,

		CKK_AES,	CKM_AES_CTR, CRYPTO_MECH_INVALID},

	};

/* Formal declaration for functions in EVP_CIPHER structure */

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

    const unsigned char *, int);

static int devcrypto_cipher_do_cipher(EVP_CIPHER_CTX *, unsigned char *,

    const unsigned char *, unsigned int);

static int devcrypto_cipher_cleanup(EVP_CIPHER_CTX *);

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

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 = {

	NID_undef,

	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 EVP_CIPHER dev_aes_192_ctr = {

	NID_undef,

	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 EVP_CIPHER dev_aes_256_ctr = {

	NID_undef,

	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

};

/*

 * This function creates a new NID.

 */

static int

devcrypto_add_NID(char *sn, char *ln)

{

	ASN1_OBJECT *o;

	int nid;

	if ((o = ASN1_OBJECT_create(OBJ_new_nid(1), (unsigned char *)"",

	    1, sn, ln)) == NULL) {

		return (0);

	}

	nid = OBJ_add_object(o); /* will return NID_undef on error */

	ASN1_OBJECT_free(o);

	return (nid);

}

/*

 * This function creates new NIDs for AES counter mode algorithms.

 * Note that OpenSSL doesn't support them now so we have to help

 * ourselves here.

 */

static int

devcrypto_add_aes_ctr_NIDs(void)

{

	if (NID_aes_256_ctr != NID_undef) /* already set */

		return (1);

	NID_aes_128_ctr = devcrypto_add_NID("AES-128-CTR", "aes-128-ctr");

	if (NID_aes_128_ctr == NID_undef)

		goto failed;

	cipher_table[DEV_AES_128_CTR].nid =

	    dev_aes_128_ctr.nid = NID_aes_128_ctr;

	NID_aes_192_ctr = devcrypto_add_NID("AES-192-CTR", "aes-192-ctr");

	if (NID_aes_192_ctr == NID_undef)

		goto failed;

	cipher_table[DEV_AES_192_CTR].nid =

	    dev_aes_192_ctr.nid = NID_aes_192_ctr;

	NID_aes_256_ctr = devcrypto_add_NID("AES-256-CTR", "aes-256-ctr");

	if (NID_aes_256_ctr == NID_undef)

		goto failed;

	cipher_table[DEV_AES_256_CTR].nid =

	    dev_aes_256_ctr.nid = NID_aes_256_ctr;

	return (1);

failed:

	return (0);

}

static void

devcrypto_free_aes_ctr_NIDs(void)

{

	ASN1_OBJECT *ob = NULL;

	if (NID_aes_128_ctr != NID_undef) {

		ob = OBJ_nid2obj(NID_aes_128_ctr);

		if (ob != NULL)

			ASN1_OBJECT_free(ob);

	}

	if (NID_aes_192_ctr != NID_undef) {

		ob = OBJ_nid2obj(NID_aes_192_ctr);

		if (ob != NULL)

			ASN1_OBJECT_free(ob);

	}

	if (NID_aes_256_ctr != NID_undef) {

		ob = OBJ_nid2obj(NID_aes_256_ctr);

		if (ob != NULL)

		ASN1_OBJECT_free(ob);

	}

}

/*

 * Open the /dev/crypto device

 */

static int

devcrypto_open()

{

	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()

{

	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) {