/*
 * Copyright (c) 2022 Rockchip Electronics Co. Ltd.
 */

#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <error.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/ioctl.h>

#include "cryptodev.h"
#include "rk_cryptodev.h"
#include "rkcrypto_mem.h"
#include "rkcrypto_core.h"
#include "rkcrypto_core_int.h"
#include "rkcrypto_trace.h"
#include "rkcrypto_rsa_helper.h"
#include "rk_list.h"

#ifndef ARRAY_SIZE
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#endif

#ifndef container_of
#define container_of(ptr, type, member) ({                      \
        const typeof(((type *) 0)->member) *__mptr = (ptr);     \
        (type *) ((char *) __mptr - offsetof(type, member));})
#endif

#define rkop_to_cop(rkop)	\
	((rkop == RK_OP_CIPHER_ENC) ? COP_ENCRYPT : COP_DECRYPT)

enum RK_CRYPTO_CONFIG_TYPE {
	RK_CONFIG_TYPE_CIPHER = 0,
	RK_CONFIG_TYPE_AE,
	RK_CONFIG_TYPE_HASH,
};

struct algo_map_info {
	uint32_t	algo;
	uint32_t	mode;
	uint32_t	crypto_id;
};

struct hash_result {
	uint8_t		hash[AALG_MAX_RESULT_LEN];
	uint32_t	len;
};

struct sess_id_node {
	uint32_t		sess_id;
	uint32_t		config_type;
	void			*priv;

	union {
		rk_cipher_config	cipher;
		rk_ae_config		ae;
		rk_hash_config		hash;
	} config;

	struct list_head	list;
};

struct ae_node_priv {
	void		*iv;
	uint8_t		*aad_virt;
	int		aad_fd;
};

static int cryptodev_fd = -1;
static int cryptodev_refcnt;

static struct list_head sess_id_list;
pthread_mutex_t sess_mutex = PTHREAD_MUTEX_INITIALIZER;

#define CHECK_CRYPTO_INITED()	do {\
					if (cryptodev_fd < 0) {\
						E_TRACE("RK_CRYPTO is uninitialized\n");\
						return RK_CRYPTO_ERR_UNINITED;\
					}\
				} while (0)

static const struct {
	const uint32_t kernel_code;
	const uint32_t rk_crypto_code;
} kernel_crypto_code[] = {
	{0,			RK_CRYPTO_SUCCESS},
	{-EINVAL,		RK_CRYPTO_ERR_PARAMETER},
	{-ENOENT,		RK_CRYPTO_ERR_NOT_SUPPORTED},
	{-ENOMEM,		RK_CRYPTO_ERR_OUT_OF_MEMORY},
	{-EACCES,		RK_CRYPTO_ERR_ACCESS_DENIED},
	{-EBUSY,		RK_CRYPTO_ERR_BUSY},
	{-ETIMEDOUT,		RK_CRYPTO_ERR_TIMEOUT},
	{-ENOKEY,		RK_CRYPTO_ERR_KEY},
	{-EBADMSG,		RK_CRYPTO_ERR_MAC_INVALID},
};

static RK_RES kernel_to_crypto_code(uint32_t tee_code)
{
	uint32_t i;

	for (i = 0; i < ARRAY_SIZE(kernel_crypto_code); i++) {
		if (tee_code == kernel_crypto_code[i].kernel_code)
			return kernel_crypto_code[i].rk_crypto_code;
	}

	/* Others convert to RK_CRYPTO_ERR_GENERIC. */
	return RK_CRYPTO_ERR_GENERIC;
}

const struct algo_map_info algo_map_tbl[] = {
	{RK_ALGO_DES,  RK_CIPHER_MODE_ECB,     CRYPTO_RK_DES_ECB},
	{RK_ALGO_DES,  RK_CIPHER_MODE_CBC,     CRYPTO_RK_DES_CBC},
	{RK_ALGO_DES,  RK_CIPHER_MODE_CFB,     CRYPTO_RK_DES_CFB},
	{RK_ALGO_DES,  RK_CIPHER_MODE_OFB,     CRYPTO_RK_DES_OFB},

	{RK_ALGO_TDES, RK_CIPHER_MODE_ECB,     CRYPTO_RK_3DES_ECB},
	{RK_ALGO_TDES, RK_CIPHER_MODE_CBC,     CRYPTO_RK_3DES_CBC},
	{RK_ALGO_TDES, RK_CIPHER_MODE_CFB,     CRYPTO_RK_3DES_CFB},
	{RK_ALGO_TDES, RK_CIPHER_MODE_OFB,     CRYPTO_RK_3DES_OFB},

	{RK_ALGO_SM4,  RK_CIPHER_MODE_ECB,     CRYPTO_RK_SM4_ECB},
	{RK_ALGO_SM4,  RK_CIPHER_MODE_CBC,     CRYPTO_RK_SM4_CBC},
	{RK_ALGO_SM4,  RK_CIPHER_MODE_CFB,     CRYPTO_RK_SM4_CFB},
	{RK_ALGO_SM4,  RK_CIPHER_MODE_OFB,     CRYPTO_RK_SM4_OFB},
	{RK_ALGO_SM4,  RK_CIPHER_MODE_CTS,     CRYPTO_RK_SM4_CTS},
	{RK_ALGO_SM4,  RK_CIPHER_MODE_CTR,     CRYPTO_RK_SM4_CTR},
	{RK_ALGO_SM4,  RK_CIPHER_MODE_XTS,     CRYPTO_RK_SM4_XTS},
	{RK_ALGO_SM4,  RK_CIPHER_MODE_CCM,     CRYPTO_RK_SM4_CCM},
	{RK_ALGO_SM4,  RK_CIPHER_MODE_GCM,     CRYPTO_RK_SM4_GCM},

	{RK_ALGO_AES,  RK_CIPHER_MODE_ECB,     CRYPTO_RK_AES_ECB},
	{RK_ALGO_AES,  RK_CIPHER_MODE_CBC,     CRYPTO_RK_AES_CBC},
	{RK_ALGO_AES,  RK_CIPHER_MODE_CFB,     CRYPTO_RK_AES_CFB},
	{RK_ALGO_AES,  RK_CIPHER_MODE_OFB,     CRYPTO_RK_AES_OFB},
	{RK_ALGO_AES,  RK_CIPHER_MODE_CTS,     CRYPTO_RK_AES_CTS},
	{RK_ALGO_AES,  RK_CIPHER_MODE_CTR,     CRYPTO_RK_AES_CTR},
	{RK_ALGO_AES,  RK_CIPHER_MODE_XTS,     CRYPTO_RK_AES_XTS},
	{RK_ALGO_AES,  RK_CIPHER_MODE_CCM,     CRYPTO_RK_AES_CCM},
	{RK_ALGO_AES,  RK_CIPHER_MODE_GCM,     CRYPTO_RK_AES_GCM},

	{RK_ALGO_MD5,         0, CRYPTO_RK_MD5},
	{RK_ALGO_SHA1,        0, CRYPTO_RK_SHA1},
	{RK_ALGO_SHA224,      0, CRYPTO_RK_SHA224},
	{RK_ALGO_SHA256,      0, CRYPTO_RK_SHA256},
	{RK_ALGO_SHA384,      0, CRYPTO_RK_SHA384},
	{RK_ALGO_SHA512,      0, CRYPTO_RK_SHA512},
	{RK_ALGO_SHA512_224,  0, CRYPTO_RK_SHA512_224},
	{RK_ALGO_SHA512_256,  0, CRYPTO_RK_SHA512_256},
	{RK_ALGO_SM3,         0, CRYPTO_RK_SM3},

	{RK_ALGO_HMAC_MD5,    0, CRYPTO_RK_MD5_HMAC},
	{RK_ALGO_HMAC_SHA1,   0, CRYPTO_RK_SHA1_HMAC},
	{RK_ALGO_HMAC_SHA256, 0, CRYPTO_RK_SHA256_HMAC},
	{RK_ALGO_HMAC_SHA512, 0, CRYPTO_RK_SHA512_HMAC},
	{RK_ALGO_HMAC_SM3,    0, CRYPTO_RK_SM3_HMAC},
	{RK_ALGO_CMAC_SM4,    0, CRYPTO_RK_SM4_CMAC},
	{RK_ALGO_CBCMAC_SM4,  0, CRYPTO_RK_SM4_CBC_MAC},
	{RK_ALGO_CMAC_AES,    0, CRYPTO_RK_AES_CMAC},
	{RK_ALGO_CBCMAC_AES,  0, CRYPTO_RK_AES_CBC_MAC},
};

static uint32_t rk_get_hash_len(uint32_t algo)
{
	switch (algo) {
	case RK_ALGO_MD5:
	case RK_ALGO_HMAC_MD5:
		return MD5_HASH_SIZE;
	case RK_ALGO_SHA1:
	case RK_ALGO_HMAC_SHA1:
		return SHA1_HASH_SIZE;
	case RK_ALGO_SHA224:
	case RK_ALGO_SHA512_224:
		return SHA224_HASH_SIZE;
	case RK_ALGO_SHA256:
	case RK_ALGO_SHA512_256:
	case RK_ALGO_HMAC_SHA256:
		return SHA256_HASH_SIZE;
	case RK_ALGO_SHA384:
		return SHA384_HASH_SIZE;
	case RK_ALGO_SHA512:
	case RK_ALGO_HMAC_SHA512:
		return SHA512_HASH_SIZE;
	case RK_ALGO_SM3:
	case RK_ALGO_HMAC_SM3:
		return SM3_HASH_SIZE;
	default:
		return 0;
	}
}

static RK_RES xioctl(int fd, unsigned long int request, void *arg)
{
	return ioctl(fd, request, arg) ? kernel_to_crypto_code(-errno) : RK_CRYPTO_SUCCESS;
}

static RK_RES rk_get_crypto_id(uint32_t algo, uint32_t mode, uint32_t *crypto_id)
{
	uint32_t i;

	for (i = 0; i < ARRAY_SIZE(algo_map_tbl); i++) {
		if (algo == algo_map_tbl[i].algo && mode == algo_map_tbl[i].mode) {
			*crypto_id = algo_map_tbl[i].crypto_id;
			return RK_CRYPTO_SUCCESS;
		}
	}

	return RK_CRYPTO_ERR_GENERIC;
}

static RK_RES rk_add_sess_node(uint32_t sess_id, uint32_t config_type, const void *config, void *priv)
{
	struct sess_id_node *node;

	node = malloc(sizeof(*node));
	if (!node) {
		E_TRACE("malloc node error!\n");
		return RK_CRYPTO_ERR_OUT_OF_MEMORY;
	}

	switch (config_type) {
	case RK_CONFIG_TYPE_CIPHER:
		memcpy(&node->config.cipher, config, sizeof(node->config.cipher));
		break;
	case RK_CONFIG_TYPE_AE:
		memcpy(&node->config.ae, config, sizeof(node->config.ae));
		break;
	case RK_CONFIG_TYPE_HASH:
		memcpy(&node->config.hash, config, sizeof(node->config.hash));
		break;
	default:
		return RK_CRYPTO_ERR_PARAMETER;
	}

	node->sess_id     = sess_id;
	node->priv        = priv;
	node->config_type = config_type;

	pthread_mutex_lock(&sess_mutex);

	list_add_tail(&node->list, &sess_id_list);

	pthread_mutex_unlock(&sess_mutex);

	return RK_CRYPTO_SUCCESS;
}

static struct sess_id_node *rk_get_sess_node(uint32_t sess_id)
{
	struct list_head *pos = NULL;
	struct sess_id_node *node = NULL;

	pthread_mutex_lock(&sess_mutex);

	list_for_each(pos, &sess_id_list) {
		node = list_entry(pos, struct sess_id_node, list);

		if (node->sess_id == sess_id) {
			goto exit;
		}
	}

exit:
	pthread_mutex_unlock(&sess_mutex);
	return node;
}

static void *rk_get_sess_config(uint32_t sess_id)
{
	struct sess_id_node *node;

	node = rk_get_sess_node(sess_id);

	return node ? &node->config : NULL;
}

static RK_RES rk_del_sess_node(uint32_t sess_id)
{
	struct list_head *pos, *n = NULL;
	struct sess_id_node *node;
	RK_RES res = RK_CRYPTO_ERR_GENERIC;

	pthread_mutex_lock(&sess_mutex);

	list_for_each_safe(pos, n, &sess_id_list) {
		node = list_entry(pos, struct sess_id_node, list);

		if (node->sess_id == sess_id) {
			list_del(pos);
			free(node);
			res = RK_CRYPTO_SUCCESS;
			goto exit;
		}
	}

exit:
	pthread_mutex_unlock(&sess_mutex);
	return res;
}

static RK_RES rk_create_session(struct session_op *sess, uint32_t config_type,
				const void *config, void *priv, rk_handle *handle)
{
	RK_RES res;

	res = xioctl(cryptodev_fd, CIOCGSESSION, sess);
	if (res) {
		if (res != RK_CRYPTO_ERR_NOT_SUPPORTED)
			E_TRACE("CIOCGSESSION error %d!\n", errno);

		goto exit;
	}

	res = rk_add_sess_node(sess->ses, config_type, config, priv);
	if (res) {
		E_TRACE("rk_add_sess_node error[%x]!\n", res);
		xioctl(cryptodev_fd, CIOCFSESSION, &sess->ses);
	} else {
		*handle = sess->ses;
	}
exit:
	return res;
}

static RK_RES rk_destroy_session(rk_handle handle)
{
	RK_RES res;

	res = xioctl(cryptodev_fd, CIOCFSESSION, &handle);
	if (res) {
		E_TRACE("CIOCFSESSION error!");
		return res;
	}

	return rk_del_sess_node(handle);
}

static RK_RES rk_update_user_iv(const void *cfg)
{
	struct sess_id_node *node;
	struct ae_node_priv *ae_priv = NULL;

	node = container_of(cfg, struct sess_id_node, config.cipher);
	if (!node)
		return RK_CRYPTO_ERR_STATE;

	if (node->priv) {
		V_TRACE("update user iv.");

		switch (node->config_type) {
		case RK_CONFIG_TYPE_CIPHER:
			memcpy(node->priv, node->config.cipher.iv, sizeof(node->config.cipher.iv));
			break;
		case RK_CONFIG_TYPE_AE:
			ae_priv = node->priv;
			memcpy(ae_priv->iv, node->config.ae.iv, node->config.ae.iv_len);
			break;
		default:
			break;
		}
	}

	return RK_CRYPTO_SUCCESS;
}

static size_t rk_mpi_bitlen(const uint8_t *data, uint32_t data_len)
{
	uint32_t i;

	while (data_len--) {
		if (*data) {
			uint8_t tmp = *data;

			for (i = 0; i < 8; i++) {
				if (!tmp)
					break;

				tmp = tmp >> 1;
			}

			return data_len * 8 + i;
		}

		data++;
	}

	return 0;
}

RK_RES rk_crypto_init(void)
{
	I_TRACE("%s\n", RK_CRYPTO_API_FULL_VERSION);

	if (cryptodev_fd < 0) {
		rk_crypto_mem_init();

		INIT_LIST_HEAD(&sess_id_list);

		/* Open the crypto device */
		cryptodev_fd = open("/dev/crypto", O_RDWR, 0);
		if (cryptodev_fd < 0) {
			E_TRACE("open cryptodev error!\n");
			return kernel_to_crypto_code(-errno);
		}

		/* Set close-on-exec (not really neede here) */
		if (fcntl(cryptodev_fd, F_SETFD, 1) == -1) {
			E_TRACE("cryptodev F_SETFD error!\n");
			goto error;
		}
	}

	cryptodev_refcnt++;

	return RK_CRYPTO_SUCCESS;
error:
	if (cryptodev_fd >= 0)
		close(cryptodev_fd);

	return RK_CRYPTO_ERR_GENERIC;
}

void rk_crypto_deinit(void)
{
	if (--cryptodev_refcnt == 0 && cryptodev_fd >= 0) {
		/* free sess_id list */
		struct sess_id_node *node;
		struct list_head *pos, *n;

		pthread_mutex_lock(&sess_mutex);

		list_for_each_safe(pos, n, &sess_id_list) {
			node = list_entry(pos, struct sess_id_node, list);
			list_del(pos);
			free(node);
		}

		pthread_mutex_unlock(&sess_mutex);

		close(cryptodev_fd);
		cryptodev_fd = -1;
		rk_crypto_mem_deinit();

	}

	if (cryptodev_refcnt < 0)
		cryptodev_refcnt = 0;
}

RK_RES rk_cipher_init(const rk_cipher_config *config, rk_handle *handle)
{
	RK_RES res;
	struct session_op sess;
	uint32_t crypto_id = 0;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(!config || !handle);

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

	res = rk_get_crypto_id(config->algo, config->mode, &crypto_id);
	if (res) {
		E_TRACE("rk_get_crypto_id error!\n");
		return res;
	}

	sess.cipher = crypto_id;
	sess.key    = (__u8 *)config->key;
	sess.keylen = config->key_len;

	return rk_create_session(&sess, RK_CONFIG_TYPE_CIPHER,
				 config, (void *)config->iv, handle);
}

RK_RES rk_cipher_crypt(rk_handle handle, int in_fd, int out_fd, uint32_t len)
{
	struct crypt_fd_op cryp;
	rk_cipher_config *cipher_cfg;
	RK_RES res = RK_CRYPTO_ERR_GENERIC;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(len == 0);

	cipher_cfg = rk_get_sess_config(handle);
	if (!cipher_cfg) {
		E_TRACE("rk_get_sess_config error!\n");
		return RK_CRYPTO_ERR_STATE;
	}

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

	/* Encrypt data.in to data.encrypted */
	cryp.ses    = handle;
	cryp.len    = len;
	cryp.src_fd = in_fd;
	cryp.dst_fd = out_fd;
	cryp.iv     = (void *)cipher_cfg->iv;
	cryp.op     = rkop_to_cop(cipher_cfg->operation);
	cryp.flags  = COP_FLAG_WRITE_IV;

	res = xioctl(cryptodev_fd, RIOCCRYPT_FD, &cryp);
	if (res) {
		E_TRACE("RIOCCRYPT_FD error!\n");
		goto exit;
	}

	res = rk_update_user_iv(cipher_cfg);
	if (res) {
		E_TRACE("rk_update_user_iv error!\n");
		goto exit;
	}

exit:
	return res;
}

RK_RES rk_cipher_crypt_virt(rk_handle handle, const uint8_t *in, uint8_t *out, uint32_t len)
{
	struct crypt_op cryp;
	rk_cipher_config *cipher_cfg;
	RK_RES res = RK_CRYPTO_ERR_GENERIC;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(!in || !out || len == 0);

	cipher_cfg = rk_get_sess_config(handle);
	if (!cipher_cfg) {
		E_TRACE("rk_get_sess_config error!\n");
		return RK_CRYPTO_ERR_STATE;
	}

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

	/* Encrypt data.in to data.encrypted */
	cryp.ses   = handle;
	cryp.len   = len;
	cryp.src   = (void *)in;
	cryp.dst   = out;
	cryp.iv    = (void *)cipher_cfg->iv;
	cryp.op    = rkop_to_cop(cipher_cfg->operation);
	cryp.flags = COP_FLAG_WRITE_IV;

	res = xioctl(cryptodev_fd, CIOCCRYPT, &cryp);
	if (res) {
		E_TRACE("CIOCCRYPT error!\n");
		goto exit;
	}

	res = rk_update_user_iv(cipher_cfg);
	if (res) {
		E_TRACE("rk_update_user_iv error!\n");
		goto exit;
	}

exit:
	return res;
}

RK_RES rk_cipher_final(rk_handle handle)
{
	CHECK_CRYPTO_INITED();

	return rk_destroy_session(handle);
}

RK_RES rk_ae_init(const rk_ae_config *config, rk_handle *handle)
{
	RK_RES res;
	struct session_op sess;
	uint32_t crypto_id = 0;
	struct ae_node_priv *ae_priv = NULL;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(!config || !handle);

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

	res = rk_get_crypto_id(config->algo, config->mode, &crypto_id);
	if (res) {
		E_TRACE("rk_get_crypto_id error!\n");
		return res;
	}

	sess.cipher = crypto_id;
	sess.key    = (__u8 *)config->key;
	sess.keylen = config->key_len;

	ae_priv = calloc(1, sizeof(*ae_priv));
	if (!ae_priv) {
		E_TRACE("malloc ae_priv error!\n");
		return RK_CRYPTO_ERR_OUT_OF_MEMORY;
	}

	ae_priv->iv = (void *)config->iv;

	return rk_create_session(&sess, RK_CONFIG_TYPE_AE,
				 config, (void *)ae_priv, handle);
}

static RK_RES ae_set_aad(rk_handle handle, int aad_fd, uint8_t *aad_virt)
{
	struct sess_id_node *node = NULL;
	struct ae_node_priv *ae_priv = NULL;

	node = rk_get_sess_node(handle);
	if (!node) {
		E_TRACE("rk_get_sess_node error!\n");
		return RK_CRYPTO_ERR_STATE;
	}

	ae_priv = node->priv;

	if (aad_fd)
		ae_priv->aad_fd = aad_fd;
	if (aad_virt)
		ae_priv->aad_virt = aad_virt;

	return RK_CRYPTO_SUCCESS;
}

RK_RES rk_ae_set_aad(rk_handle handle, int aad_fd)
{
	return ae_set_aad(handle, aad_fd, NULL);
}

RK_RES rk_ae_set_aad_virt(rk_handle handle, uint8_t *aad_virt)
{
	return ae_set_aad(handle, 0, aad_virt);
}

RK_RES rk_ae_crypt(rk_handle handle, int in_fd, int out_fd, uint32_t len, uint8_t *tag)
{
	struct crypt_auth_fd_op op;
	rk_ae_config *ae_cfg = NULL;
	struct sess_id_node *node = NULL;
	struct ae_node_priv *ae_priv = NULL;
	RK_RES res = RK_CRYPTO_ERR_GENERIC;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(len == 0);

	node = rk_get_sess_node(handle);
	if (!node) {
		E_TRACE("rk_get_sess_node error!\n");
		return RK_CRYPTO_ERR_STATE;
	}

	ae_priv =  node->priv;

	/* make sure rk_ae_set_aad has been called */
	RK_CRYPTO_CHECK_PARAM(ae_priv->aad_fd == 0);

	ae_cfg = rk_get_sess_config(handle);
	if (!ae_cfg) {
		E_TRACE("rk_get_sess_config error!\n");
		return RK_CRYPTO_ERR_STATE;
	}

	if (ae_cfg->tag_len)
		RK_CRYPTO_CHECK_PARAM(!tag);

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

	/* Encrypt data.in to data.encrypted */
	op.ses      = handle;
	op.op       = rkop_to_cop(ae_cfg->operation);
	op.flags    = COP_FLAG_WRITE_IV | COP_FLAG_AEAD_RK_TYPE;
	op.len      = len;
	op.src_fd   = in_fd;
	op.dst_fd   = out_fd;
	op.iv       = (unsigned long)ae_cfg->iv | (__u64)0;
	op.iv_len   = ae_cfg->iv_len;
	op.auth_fd  = ae_priv->aad_fd;
	op.auth_len = ae_cfg->aad_len;
	op.tag_len  = ae_cfg->tag_len;
	op.tag      = (unsigned long)tag | (__u64)0;

	V_TRACE("in and out are %s address.", (in_fd == out_fd) ? "the same" : "different");
	V_TRACE("cipher data len = %d, aad_len = %d, tag_len = %d",
		len, ae_cfg->aad_len, ae_cfg->tag_len);

	res = xioctl(cryptodev_fd, RIOCAUTHCRYPT_FD, &op);
	if (res) {
		E_TRACE("RIOCCRYPT_FD error!\n");
		goto exit;
	}

	res = rk_update_user_iv(ae_cfg);
	if (res) {
		E_TRACE("rk_update_user_iv error[0x%x]!\n", res);
		goto exit;
	}

exit:
	return res;
}

RK_RES rk_ae_crypt_virt(rk_handle handle, const uint8_t *in, uint8_t *out, uint32_t len,
			uint8_t *tag)
{
	struct crypt_auth_op op;
	rk_ae_config *ae_cfg = NULL;
	struct sess_id_node *node = NULL;
	struct ae_node_priv *ae_priv = NULL;
	RK_RES res = RK_CRYPTO_ERR_GENERIC;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(!in || !out || len == 0);

	node = rk_get_sess_node(handle);
	if (!node) {
		E_TRACE("rk_get_sess_node error!\n");
		return RK_CRYPTO_ERR_STATE;
	}

	ae_priv =  node->priv;

	/* make sure rk_ae_set_aad_virt has been called */
	RK_CRYPTO_CHECK_PARAM(ae_priv->aad_virt == 0);

	ae_cfg = rk_get_sess_config(handle);
	if (!ae_cfg) {
		E_TRACE("rk_get_sess_config error!\n");
		return RK_CRYPTO_ERR_STATE;
	}

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

	/* Encrypt data.in to data.encrypted */
	op.ses      = handle;
	op.op       = rkop_to_cop(ae_cfg->operation);
	op.flags    = COP_FLAG_WRITE_IV | COP_FLAG_AEAD_RK_TYPE;
	op.len      = len;
	op.src      = (void *)in;
	op.dst      = out;
	op.iv       = (void *)ae_cfg->iv;
	op.iv_len   = ae_cfg->iv_len;
	op.auth_src = ae_priv->aad_virt;
	op.auth_len = ae_cfg->aad_len;
	op.tag_len  = ae_cfg->tag_len;
	op.tag      = tag;

	V_TRACE("in and out are %s address.", (in == out) ? "the same" : "different");
	V_TRACE("cipher data len = %d, aad_len = %d, tag_len = %d",
		len, ae_cfg->aad_len, ae_cfg->tag_len);

	res = xioctl(cryptodev_fd, CIOCAUTHCRYPT, &op);
	if (res) {
		E_TRACE("CIOCAUTHCRYPT error!\n");
		goto exit;
	}

	res = rk_update_user_iv(ae_cfg);
	if (res) {
		E_TRACE("rk_update_user_iv error[0x%x]!\n", res);
		goto exit;
	}

exit:
	return res;
}

RK_RES rk_ae_final(rk_handle handle)
{
	struct sess_id_node *node = NULL;

	CHECK_CRYPTO_INITED();

	node = rk_get_sess_node(handle);
	if (!node) {
		E_TRACE("rk_get_sess_node error!\n");
		return RK_CRYPTO_ERR_STATE;
	}

	free(node->priv);

	return rk_destroy_session(handle);
}

RK_RES rk_hash_init(const rk_hash_config *config, rk_handle *handle)
{
	RK_RES res;
	struct session_op sess;
	uint32_t crypto_id = 0;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(!config || !handle);

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

	res = rk_get_crypto_id(config->algo, 0, &crypto_id);
	if (res) {
		E_TRACE("rk_get_crypto_id error!\n");
		return res;
	}

	sess.mac = crypto_id;
	if (config->key && config->key_len) {
		sess.mackey    = config->key;
		sess.mackeylen = config->key_len;
	}

	return rk_create_session(&sess, RK_CONFIG_TYPE_HASH, config, NULL, handle);
}

RK_RES rk_hash_update(rk_handle handle, int data_fd, uint32_t data_len)
{
	struct crypt_fd_op cryp;
	RK_RES res;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(data_len == 0);

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

	cryp.ses    = handle;
	cryp.len    = data_len;
	cryp.src_fd = data_fd;
	cryp.mac    = NULL;
	cryp.flags  = COP_FLAG_UPDATE;

	res = xioctl(cryptodev_fd, RIOCCRYPT_FD, &cryp);
	if (res) {
		E_TRACE("RIOCCRYPT_FD error!\n");
		return res;
	}

	return RK_CRYPTO_SUCCESS;
}

RK_RES rk_hash_update_virt(rk_handle handle, const uint8_t *data, uint32_t data_len)
{
	struct crypt_op cryp;
	RK_RES res;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(!data || data_len == 0);

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

	cryp.ses   = handle;
	cryp.len   = data_len;
	cryp.src   = (void *)data;
	cryp.mac   = NULL;
	cryp.flags = COP_FLAG_UPDATE;

	res = xioctl(cryptodev_fd, CIOCCRYPT, &cryp);
	if (res) {
		E_TRACE("CIOCCRYPT error!\n");
		return res;
	}

	return RK_CRYPTO_SUCCESS;
}

RK_RES rk_hash_final(rk_handle handle, uint8_t *hash)
{
	RK_RES res = RK_CRYPTO_SUCCESS;
	struct crypt_op cryp;
	rk_hash_config *hash_cfg;
	uint8_t hash_tmp[SHA512_HASH_SIZE];
	uint32_t hash_tmp_len;

	CHECK_CRYPTO_INITED();

	hash_cfg = rk_get_sess_config(handle);
	if (!hash_cfg) {
		E_TRACE("handle[%u] rk_get_sess_config  error!\n", handle);
		goto exit;
	}

	hash_tmp_len = rk_get_hash_len(hash_cfg->algo);

	/* final update 0 Byte */
	memset(&cryp, 0, sizeof(cryp));

	cryp.ses   = handle;
	cryp.mac   = hash_tmp;
	cryp.flags = COP_FLAG_FINAL;

	res = xioctl(cryptodev_fd, CIOCCRYPT, &cryp);
	if (res) {
		E_TRACE("CIOCCRYPT error!\n");
		goto exit;
	}

	if (hash)
		memcpy(hash, hash_tmp, hash_tmp_len);

exit:
	return rk_destroy_session(handle);
}

RK_RES rk_crypto_fd_ioctl(uint32_t request, struct crypt_fd_map_op *mop)
{
	RK_RES res;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(request != RIOCCRYPT_FD_MAP &&
			   request != RIOCCRYPT_FD_UNMAP);
	RK_CRYPTO_CHECK_PARAM(!mop);

	res = xioctl(cryptodev_fd, request, mop);
	if (res) {
		E_TRACE("ioctl cryptodev_fd failed!");
		return res;
	}

	return RK_CRYPTO_SUCCESS;
}

static RK_RES rk_rsa_crypt_common(void *key, uint16_t flag, uint16_t op,
				  const uint8_t *in, uint32_t in_len,
				  uint8_t *out, uint32_t *out_len)
{
	RK_RES res = RK_CRYPTO_ERR_GENERIC;
	uint8_t *asn1_key = NULL;
	uint16_t asn1_key_len = RK_RSA_BER_KEY_MAX, key_bits;
	struct crypt_rsa_op rop;

	CHECK_CRYPTO_INITED();

	RK_CRYPTO_CHECK_PARAM(!key);

	asn1_key = malloc(asn1_key_len);
	if (!asn1_key) {
		E_TRACE("ioctl cryptodev_fd failed!");
		return RK_CRYPTO_ERR_OUT_OF_MEMORY;
	}

	memset(asn1_key, 0x00, asn1_key_len);

	/* Encode the key in ASN1 format */
	if ((flag & COP_FLAG_RSA_PRIV) == COP_FLAG_RSA_PRIV)
		res = rk_rsa_privkey_encode((rk_rsa_priv_key_pack *)key,
					    asn1_key, &asn1_key_len, &key_bits);
	else
		res = rk_rsa_pubkey_encode((rk_rsa_pub_key_pack *)key,
					   asn1_key, &asn1_key_len, &key_bits);

	if (res) {
		E_TRACE("asn1 encode failed %x!", res);
		res = RK_CRYPTO_ERR_KEY;
		goto exit;
	}

	if (key_bits / 8 != in_len) {
		E_TRACE("RIOCCRYPT_RSA_CRYPT length not match!");
		res = RK_CRYPTO_ERR_PARAMETER;
		goto exit;
	}

	memset(&rop, 0x00, sizeof(rop));

	rop.op      = op;
	rop.flags   = flag;
	rop.key     = (unsigned long)asn1_key | (__u64)0;
	rop.key_len = asn1_key_len;
	rop.in      = (unsigned long)in | (__u64)0;
	rop.in_len  = in_len;
	rop.out     = (unsigned long)out | (__u64)0;

	res = xioctl(cryptodev_fd, RIOCCRYPT_RSA_CRYPT, &rop);
	if (res) {
		E_TRACE("ioctl cryptodev_fd failed! [%d]", -errno);
		goto exit;
	}

	*out_len = rop.out_len;
	res = RK_CRYPTO_SUCCESS;
exit:
	memset(asn1_key, 0x00, asn1_key_len);

	if (asn1_key)
		free(asn1_key);

	return res;
}

RK_RES rk_rsa_pub_encrypt(const rk_rsa_pub_key_pack *pub, enum RK_RSA_CRYPT_PADDING padding,
			  const uint8_t *in, uint32_t in_len, uint8_t *out, uint32_t *out_len)
{
	RK_RES res;
	uint8_t data_pad[MAX_RSA_KEY_BITS / 8];
	uint32_t data_pad_len = sizeof(data_pad);

	RK_CRYPTO_CHECK_PARAM(!pub || !in || !out || !out_len);
	RK_CRYPTO_CHECK_PARAM(in_len == 0);

	/* deal with padding */
	res = rk_rsa_crypt_do_padding(padding, pub->key.n_len, false,
				      in, in_len, data_pad, &data_pad_len);
	if (res) {
		D_TRACE("rsa padding %d error!", padding);
		return res;
	}

	return rk_rsa_crypt_common((void *)pub, COP_FLAG_RSA_PUB, AOP_ENCRYPT,
				   data_pad, data_pad_len, out, out_len);
}

RK_RES rk_rsa_priv_decrypt(const rk_rsa_priv_key_pack *priv, enum RK_RSA_CRYPT_PADDING padding,
			   const uint8_t *in, uint32_t in_len, uint8_t *out, uint32_t *out_len)
{
	RK_RES res;
	uint8_t data_pad[MAX_RSA_KEY_BITS / 8];
	uint32_t data_pad_len = sizeof(data_pad);

	RK_CRYPTO_CHECK_PARAM(!priv || !in || !out || !out_len);
	RK_CRYPTO_CHECK_PARAM(priv->key.n_len != in_len);

	res = rk_rsa_crypt_common((void *)priv, COP_FLAG_RSA_PRIV, AOP_DECRYPT,
				   in, in_len, data_pad, &data_pad_len);
	if (res) {
		D_TRACE("rk_rsa_crypt_common error! %x", res);
		return res;
	}

	return rk_rsa_crypt_undo_padding(padding, priv->key.n_len, true,
					 data_pad, data_pad_len, out, out_len);
}

RK_RES rk_rsa_priv_encrypt(const rk_rsa_priv_key_pack *priv, enum RK_RSA_CRYPT_PADDING padding,
			   const uint8_t *in, uint32_t in_len, uint8_t *out, uint32_t *out_len)
{
	RK_RES res;
	uint8_t data_pad[MAX_RSA_KEY_BITS / 8];
	uint32_t data_pad_len = sizeof(data_pad);

	RK_CRYPTO_CHECK_PARAM(!priv || !in || !out || !out_len);
	RK_CRYPTO_CHECK_PARAM(in_len == 0);

	/* deal with padding */
	res = rk_rsa_crypt_do_padding(padding, priv->key.n_len, true,
				      in, in_len, data_pad, &data_pad_len);
	if (res) {
		D_TRACE("rsa padding %d error!", padding);
		return res;
	}

	return rk_rsa_crypt_common((void *)priv, COP_FLAG_RSA_PRIV, AOP_DECRYPT,
				   data_pad, data_pad_len, out, out_len);
}

RK_RES rk_rsa_pub_decrypt(const rk_rsa_pub_key_pack *pub, enum RK_RSA_CRYPT_PADDING padding,
			  const uint8_t *in, uint32_t in_len, uint8_t *out, uint32_t *out_len)
{
	RK_RES res;
	uint8_t data_pad[MAX_RSA_KEY_BITS / 8];
	uint32_t data_pad_len = sizeof(data_pad);

	RK_CRYPTO_CHECK_PARAM(!pub || !in || !out || !out_len);
	RK_CRYPTO_CHECK_PARAM(pub->key.n_len != in_len);

	res = rk_rsa_crypt_common((void *)pub, COP_FLAG_RSA_PUB, AOP_ENCRYPT,
				   in, in_len, data_pad, &data_pad_len);
	if (res) {
		D_TRACE("rk_rsa_crypt_common error! %x", res);
		return res;
	}

	return rk_rsa_crypt_undo_padding(padding, pub->key.n_len, false,
					 data_pad, data_pad_len, out, out_len);
}

RK_RES rk_rsa_sign(const rk_rsa_priv_key_pack *priv, enum RK_RSA_SIGN_PADDING padding,
		   const uint8_t *in, uint32_t in_len, const uint8_t *hash,
		   uint8_t *out, uint32_t *out_len)
{
	RK_RES res;
	uint8_t data_pad[MAX_RSA_KEY_BITS / 8];
	uint32_t data_pad_len = sizeof(data_pad);

	RK_CRYPTO_CHECK_PARAM(!in && !hash);
	RK_CRYPTO_CHECK_PARAM(in && in_len == 0);
	RK_CRYPTO_CHECK_PARAM(!priv || !out || !out_len);

	/* deal with padding */
	res = rk_rsa_sign_do_padding(padding, priv->key.n_len,
				     rk_mpi_bitlen(priv->key.n, priv->key.n_len),
				     in, in_len, hash, data_pad, &data_pad_len);
	if (res) {
		D_TRACE("rsa padding %d error!", padding);
		return res;
	}

	return rk_rsa_crypt_common((void *)priv, COP_FLAG_RSA_PRIV, AOP_DECRYPT,
				   data_pad, data_pad_len, out, out_len);
}

RK_RES rk_rsa_verify(const rk_rsa_pub_key_pack *pub, enum RK_RSA_SIGN_PADDING padding,
		     const uint8_t *in, uint32_t in_len, const uint8_t *hash,
		     uint8_t *sign, uint32_t sign_len)
{
	RK_RES res;
	uint8_t dec_pad[MAX_RSA_KEY_BITS / 8];
	uint32_t dec_pad_len = sizeof(dec_pad);

	RK_CRYPTO_CHECK_PARAM(!in && !hash);
	RK_CRYPTO_CHECK_PARAM(in && in_len == 0);
	RK_CRYPTO_CHECK_PARAM(!pub || !sign);
	RK_CRYPTO_CHECK_PARAM(pub->key.n_len != sign_len);

	res = rk_rsa_crypt_common((void *)pub, COP_FLAG_RSA_PUB, AOP_ENCRYPT,
				  sign, sign_len, dec_pad, &dec_pad_len);
	if (res) {
		D_TRACE("rsa rk_rsa_crypt_common error[%x]!", res);
		goto exit;
	}

	/* deal with padding */
	res = rk_rsa_sign_undo_padding(padding, pub->key.n_len,
				       rk_mpi_bitlen(pub->key.n, pub->key.n_len),
				       in, in_len, hash, dec_pad);
	if (res) {
		D_TRACE("rsa padding %d error!", padding);
		goto exit;
	}

exit:
	return res ? RK_CRYPTO_ERR_VERIFY : RK_CRYPTO_SUCCESS;
}