blob: df46d47d03219198ea6ca15e709104b584c8973a [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Copyright (C) 2023 MediaTek Inc.
*
* Author: Chris.Chou <chris.chou@mediatek.com>
* Ren-Ting Wang <ren-ting.wang@mediatek.com>
*/
#include <linux/bitops.h>
#include <crypto/aes.h>
#include <crypto/authenc.h>
#include <crypto/gcm.h>
#include <crypto/ghash.h>
#include <crypto/ctr.h>
#include <crypto/xts.h>
#include <crypto/internal/des.h>
#include <crypto/skcipher.h>
#include <crypto/internal/skcipher.h>
#include <crypto/aead.h>
#include <crypto/internal/aead.h>
#include "crypto-eip/crypto-eip.h"
#include "crypto-eip/ddk-wrapper.h"
#include "crypto-eip/lookaside.h"
#include "crypto-eip/internal.h"
static int mtk_crypto_skcipher_send(struct crypto_async_request *async)
{
struct skcipher_request *req = skcipher_request_cast(async);
struct mtk_crypto_cipher_req *mtk_req = skcipher_request_ctx(req);
struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
int ret = 0;
ret = crypto_basic_cipher(async, mtk_req, req->src, req->dst, req->cryptlen,
0, 0, req->iv, skcipher->ivsize);
if (ret != 0)
async->complete(async, ret);
return ret;
}
static int mtk_crypto_skcipher_handle_result(struct mtk_crypto_result *res, int err)
{
struct crypto_async_request *async = res->async;
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(async->tfm);
struct skcipher_request *req = skcipher_request_cast(async);
struct mtk_crypto_cipher_req *mtk_req = skcipher_request_ctx(req);
struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
if (ctx->mode == MTK_CRYPTO_MODE_CBC && mtk_req->direction == MTK_CRYPTO_ENCRYPT)
sg_pcopy_to_buffer(req->dst, mtk_req->nr_dst, req->iv, skcipher->ivsize,
req->cryptlen - skcipher->ivsize);
if (req->src == req->dst) {
dma_unmap_sg(crypto_dev, req->src, mtk_req->nr_src, DMA_BIDIRECTIONAL);
} else {
dma_unmap_sg(crypto_dev, req->src, mtk_req->nr_src, DMA_TO_DEVICE);
dma_unmap_sg(crypto_dev, req->dst, mtk_req->nr_dst, DMA_FROM_DEVICE);
}
async->complete(async, err);
crypto_free_sglist(res->eip.pkt_handle);
crypto_free_sglist(res->dst);
crypto_free_sa(res->eip.sa);
crypto_free_token(res->eip.token);
kfree(res->eip.token_context);
return 0;
}
static int mtk_crypto_aead_send(struct crypto_async_request *async)
{
struct aead_request *req = aead_request_cast(async);
struct crypto_aead *tfm = crypto_aead_reqtfm(req);
struct mtk_crypto_cipher_req *mtk_req = aead_request_ctx(req);
int ret;
ret = crypto_aead_cipher(async, mtk_req, req->src, req->dst, req->cryptlen,
req->assoclen, crypto_aead_authsize(tfm), req->iv,
crypto_aead_ivsize(tfm));
if (ret != 0)
async->complete(async, ret);
return ret;
}
static int mtk_crypto_aead_handle_result(struct mtk_crypto_result *res, int err)
{
struct crypto_async_request *async = res->async;
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(async->tfm);
struct aead_request *req = aead_request_cast(async);
struct mtk_crypto_cipher_req *mtk_req = aead_request_ctx(req);
struct crypto_aead *aead = crypto_aead_reqtfm(req);
int pkt_size;
uint8_t *temp;
if (ctx->mode == MTK_CRYPTO_MODE_CCM && mtk_req->direction == MTK_CRYPTO_DECRYPT) {
pkt_size = req->cryptlen + req->assoclen - crypto_aead_authsize(aead);
temp = kmalloc(pkt_size, GFP_KERNEL);
if (!temp) {
CRYPTO_ERR("no enough memory for result\n");
goto free_dma;
}
memset(temp, 0, pkt_size);
sg_copy_to_buffer(req->dst, mtk_req->nr_dst, temp + 8, pkt_size - 8);
sg_copy_from_buffer(req->dst, mtk_req->nr_dst, temp, pkt_size);
kfree(temp);
}
free_dma:
if (req->src == req->dst) {
dma_unmap_sg(crypto_dev, req->src, mtk_req->nr_src, DMA_BIDIRECTIONAL);
} else {
dma_unmap_sg(crypto_dev, req->src, mtk_req->nr_src, DMA_TO_DEVICE);
dma_unmap_sg(crypto_dev, req->dst, mtk_req->nr_dst, DMA_FROM_DEVICE);
}
crypto_free_sglist(res->eip.pkt_handle);
crypto_free_sglist(res->dst);
crypto_free_sa(res->eip.sa);
crypto_free_token(res->eip.token);
kfree(res->eip.token_context);
async->complete(async, err);
return 0;
}
static int mtk_crypto_skcipher_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct mtk_crypto_alg_template *tmpl =
container_of(tfm->__crt_alg, struct mtk_crypto_alg_template,
alg.skcipher.base);
crypto_skcipher_set_reqsize(__crypto_skcipher_cast(tfm),
sizeof(struct mtk_crypto_cipher_req));
ctx->priv = tmpl->priv;
ctx->base.send = mtk_crypto_skcipher_send;
ctx->base.handle_result = mtk_crypto_skcipher_handle_result;
return 0;
}
static int mtk_crypto_skcipher_aes_cbc_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_skcipher_cra_init(tfm);
ctx->alg = MTK_CRYPTO_AES;
ctx->blocksz = AES_BLOCK_SIZE;
ctx->mode = MTK_CRYPTO_MODE_CBC;
return 0;
}
static int mtk_crypto_skcipher_aes_ecb_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_skcipher_cra_init(tfm);
ctx->alg = MTK_CRYPTO_AES;
ctx->mode = MTK_CRYPTO_MODE_ECB;
ctx->blocksz = 0;
return 0;
}
static int mtk_crypto_queue_req(struct crypto_async_request *base,
struct mtk_crypto_cipher_req *mtk_req,
enum mtk_crypto_cipher_direction dir)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
struct mtk_crypto_priv *priv = ctx->priv;
int ret;
mtk_req->direction = dir;
spin_lock_bh(&priv->mtk_eip_queue.queue_lock);
ret = crypto_enqueue_request(&priv->mtk_eip_queue.queue, base);
spin_unlock_bh(&priv->mtk_eip_queue.queue_lock);
queue_work(priv->mtk_eip_queue.workqueue,
&priv->mtk_eip_queue.work_data.work);
return ret;
}
static int mtk_crypto_decrypt(struct skcipher_request *req)
{
return mtk_crypto_queue_req(&req->base, skcipher_request_ctx(req), MTK_CRYPTO_DECRYPT);
}
static int mtk_crypto_encrypt(struct skcipher_request *req)
{
return mtk_crypto_queue_req(&req->base, skcipher_request_ctx(req), MTK_CRYPTO_ENCRYPT);
}
static int mtk_crypto_skcipher_aes_setkey(struct crypto_skcipher *ctfm,
const u8 *key, unsigned int len)
{
struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct crypto_aes_ctx aes;
int ret;
int i;
ret = aes_expandkey(&aes, key, len);
if (ret)
return ret;
for (i = 0; i < len / sizeof(u32); i++)
ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
ctx->key_len = len;
memzero_explicit(&aes, sizeof(aes));
return 0;
}
static void mtk_crypto_skcipher_cra_exit(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
memzero_explicit(ctx->key, sizeof(ctx->key));
}
struct mtk_crypto_alg_template mtk_crypto_cbc_aes = {
.type = MTK_CRYPTO_ALG_TYPE_SKCIPHER,
.alg.skcipher = {
.setkey = mtk_crypto_skcipher_aes_setkey,
.encrypt = mtk_crypto_encrypt,
.decrypt = mtk_crypto_decrypt,
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE,
.base = {
.cra_name = "cbc(aes)",
.cra_driver_name = "crypto-eip-cbc-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_init = mtk_crypto_skcipher_aes_cbc_cra_init,
.cra_exit = mtk_crypto_skcipher_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_skcipher_aes_cfb_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_skcipher_cra_init(tfm);
ctx->alg = MTK_CRYPTO_AES;
ctx->blocksz = AES_BLOCK_SIZE;
ctx->mode = MTK_CRYPTO_MODE_CFB;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_cfb_aes = {
.type = MTK_CRYPTO_ALG_TYPE_SKCIPHER,
.alg.skcipher = {
.setkey = mtk_crypto_skcipher_aes_setkey,
.encrypt = mtk_crypto_encrypt,
.decrypt = mtk_crypto_decrypt,
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE,
.base = {
.cra_name = "cfb(aes)",
.cra_driver_name = "crypto-eip-cfb-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_skcipher_aes_cfb_cra_init,
.cra_exit = mtk_crypto_skcipher_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_skcipher_aes_ofb_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_skcipher_cra_init(tfm);
ctx->alg = MTK_CRYPTO_AES;
ctx->blocksz = AES_BLOCK_SIZE;
ctx->mode = MTK_CRYPTO_MODE_OFB;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_ofb_aes = {
.type = MTK_CRYPTO_ALG_TYPE_SKCIPHER,
.alg.skcipher = {
.setkey = mtk_crypto_skcipher_aes_setkey,
.encrypt = mtk_crypto_encrypt,
.decrypt = mtk_crypto_decrypt,
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE,
.base = {
.cra_name = "ofb(aes)",
.cra_driver_name = "crypto-eip-ofb-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_skcipher_aes_ofb_cra_init,
.cra_exit = mtk_crypto_skcipher_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
struct mtk_crypto_alg_template mtk_crypto_ecb_aes = {
.type = MTK_CRYPTO_ALG_TYPE_SKCIPHER,
.alg.skcipher = {
.setkey = mtk_crypto_skcipher_aes_setkey,
.encrypt = mtk_crypto_encrypt,
.decrypt = mtk_crypto_decrypt,
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.base = {
.cra_name = "ecb(aes)",
.cra_driver_name = "crypto-eip-ecb-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_init = mtk_crypto_skcipher_aes_ecb_cra_init,
.cra_exit = mtk_crypto_skcipher_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_skcipher_aesctr_setkey(struct crypto_skcipher *ctfm,
const u8 *key, unsigned int len)
{
struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct crypto_aes_ctx aes;
int ret;
int i;
unsigned int keylen;
ctx->nonce = *(u32 *)(key + len - CTR_RFC3686_NONCE_SIZE);
keylen = len - CTR_RFC3686_NONCE_SIZE;
ret = aes_expandkey(&aes, key, keylen);
if (ret)
return ret;
for (i = 0; i < keylen / sizeof(u32); i++)
ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
ctx->key_len = keylen;
memzero_explicit(&aes, sizeof(aes));
return 0;
}
static int mtk_crypto_skcipher_aes_ctr_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_skcipher_cra_init(tfm);
ctx->alg = MTK_CRYPTO_AES;
ctx->blocksz = AES_BLOCK_SIZE;
ctx->mode = MTK_CRYPTO_MODE_CTR;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_ctr_aes = {
.type = MTK_CRYPTO_ALG_TYPE_SKCIPHER,
.alg.skcipher = {
.setkey = mtk_crypto_skcipher_aesctr_setkey,
.encrypt = mtk_crypto_encrypt,
.decrypt = mtk_crypto_decrypt,
.min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
.max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
.ivsize = CTR_RFC3686_IV_SIZE,
.base = {
.cra_name = "rfc3686(ctr(aes))",
.cra_driver_name = "crypto-eip-ctr-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_skcipher_aes_ctr_cra_init,
.cra_exit = mtk_crypto_skcipher_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_des_setkey(struct crypto_skcipher *ctfm, const u8 *key,
unsigned int len)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_skcipher_ctx(ctfm);
int ret;
ret = verify_skcipher_des_key(ctfm, key);
if (ret)
return ret;
memcpy(ctx->key, key, len);
ctx->key_len = len;
return 0;
}
static int mtk_crypto_skcipher_des_cbc_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_skcipher_cra_init(tfm);
ctx->alg = MTK_CRYPTO_DES;
ctx->blocksz = DES_BLOCK_SIZE;
ctx->mode = MTK_CRYPTO_MODE_CBC;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_cbc_des = {
.type = MTK_CRYPTO_ALG_TYPE_SKCIPHER,
.alg.skcipher = {
.setkey = mtk_crypto_des_setkey,
.encrypt = mtk_crypto_encrypt,
.decrypt = mtk_crypto_decrypt,
.min_keysize = DES_KEY_SIZE,
.max_keysize = DES_KEY_SIZE,
.ivsize = DES_BLOCK_SIZE,
.base = {
.cra_name = "cbc(des)",
.cra_driver_name = "crypto-eip-cbc-des",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_skcipher_des_cbc_cra_init,
.cra_exit = mtk_crypto_skcipher_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_skcipher_des_ecb_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_skcipher_cra_init(tfm);
ctx->alg = MTK_CRYPTO_DES;
ctx->mode = MTK_CRYPTO_MODE_ECB;
ctx->blocksz = 0;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_ecb_des = {
.type = MTK_CRYPTO_ALG_TYPE_SKCIPHER,
.alg.skcipher = {
.setkey = mtk_crypto_des_setkey,
.encrypt = mtk_crypto_encrypt,
.decrypt = mtk_crypto_decrypt,
.min_keysize = DES_KEY_SIZE,
.max_keysize = DES_KEY_SIZE,
.base = {
.cra_name = "ecb(des)",
.cra_driver_name = "crypto-eip-ecb-des",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_skcipher_des_ecb_cra_init,
.cra_exit = mtk_crypto_skcipher_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_des3_ede_setkey(struct crypto_skcipher *ctfm,
const u8 *key, unsigned int len)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_skcipher_ctx(ctfm);
int err;
err = verify_skcipher_des3_key(ctfm, key);
if (err)
return err;
memcpy(ctx->key, key, len);
ctx->key_len = len;
return 0;
}
static int mtk_crypto_skcipher_des3_cbc_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_skcipher_cra_init(tfm);
ctx->alg = MTK_CRYPTO_3DES;
ctx->mode = MTK_CRYPTO_MODE_CBC;
ctx->blocksz = 0;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_cbc_des3_ede = {
.type = MTK_CRYPTO_ALG_TYPE_SKCIPHER,
.alg.skcipher = {
.setkey = mtk_crypto_des3_ede_setkey,
.encrypt = mtk_crypto_encrypt,
.decrypt = mtk_crypto_decrypt,
.min_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE,
.ivsize = DES3_EDE_BLOCK_SIZE,
.base = {
.cra_name = "cbc(des3_ede)",
.cra_driver_name = "crypto-eip-cbc-des3_ede",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_skcipher_des3_cbc_cra_init,
.cra_exit = mtk_crypto_skcipher_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_skcipher_des3_ecb_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_skcipher_cra_init(tfm);
ctx->alg = MTK_CRYPTO_3DES;
ctx->mode = MTK_CRYPTO_MODE_ECB;
ctx->blocksz = 0;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_ecb_des3_ede = {
.type = MTK_CRYPTO_ALG_TYPE_SKCIPHER,
.alg.skcipher = {
.setkey = mtk_crypto_des3_ede_setkey,
.encrypt = mtk_crypto_encrypt,
.decrypt = mtk_crypto_decrypt,
.min_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE,
.base = {
.cra_name = "ecb(des3_ede)",
.cra_driver_name = "crypto-eip-ecb-des3_ede",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_skcipher_des3_ecb_cra_init,
.cra_exit = mtk_crypto_skcipher_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_encrypt(struct aead_request *req)
{
struct mtk_crypto_cipher_req *creq = aead_request_ctx(req);
return mtk_crypto_queue_req(&req->base, creq, MTK_CRYPTO_ENCRYPT);
}
static int mtk_crypto_aead_decrypt(struct aead_request *req)
{
struct mtk_crypto_cipher_req *creq = aead_request_ctx(req);
return mtk_crypto_queue_req(&req->base, creq, MTK_CRYPTO_DECRYPT);
}
static void mtk_crypto_aead_cra_exit(struct crypto_tfm *tfm)
{
mtk_crypto_skcipher_cra_exit(tfm);
}
static int mtk_crypto_aead_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct mtk_crypto_alg_template *tmpl =
container_of(tfm->__crt_alg, struct mtk_crypto_alg_template, alg.aead.base);
crypto_aead_set_reqsize(__crypto_aead_cast(tfm), sizeof(struct mtk_crypto_cipher_req));
ctx->priv = tmpl->priv;
ctx->alg = MTK_CRYPTO_AES;
ctx->blocksz = AES_BLOCK_SIZE;
ctx->mode = MTK_CRYPTO_MODE_CBC;
ctx->aead = true;
ctx->base.send = mtk_crypto_aead_send;
ctx->base.handle_result = mtk_crypto_aead_handle_result;
return 0;
}
static int mtk_crypto_aead_sha1_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_cra_init(tfm);
ctx->hash_alg = MTK_CRYPTO_ALG_SHA1;
ctx->state_sz = SHA1_DIGEST_SIZE;
return 0;
}
static int mtk_crypto_aead_setkey(struct crypto_aead *ctfm, const u8 *key, unsigned int len)
{
struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct mtk_crypto_ahash_export_state istate, ostate;
struct crypto_authenc_keys keys;
struct crypto_aes_ctx aes;
int err = -EINVAL, i;
memset(&istate, 0, sizeof(struct mtk_crypto_ahash_export_state));
memset(&ostate, 0, sizeof(struct mtk_crypto_ahash_export_state));
if (unlikely(crypto_authenc_extractkeys(&keys, key, len)))
goto badkey;
if (ctx->mode == MTK_CRYPTO_MODE_CTR) {
if (unlikely(keys.enckeylen < CTR_RFC3686_NONCE_SIZE))
goto badkey;
ctx->nonce = *(u32 *)(keys.enckey + keys.enckeylen - CTR_RFC3686_NONCE_SIZE);
keys.enckeylen -= CTR_RFC3686_NONCE_SIZE;
}
switch (ctx->alg) {
case MTK_CRYPTO_AES:
err = aes_expandkey(&aes, keys.enckey, keys.enckeylen);
if (unlikely(err))
goto badkey;
break;
case MTK_CRYPTO_DES:
err = verify_aead_des_key(ctfm, keys.enckey, keys.enckeylen);
if (unlikely(err))
goto badkey;
break;
case MTK_CRYPTO_3DES:
err = verify_aead_des3_key(ctfm, keys.enckey, keys.enckeylen);
if (unlikely(err))
goto badkey;
break;
default:
CRYPTO_ERR("aead: unsupported cipher algorithm\n");
goto badkey;
}
switch (ctx->hash_alg) {
case MTK_CRYPTO_ALG_SHA1:
err = mtk_crypto_hmac_setkey("crypto-eip-sha1", keys.authkey,
keys.authkeylen, &istate, &ostate);
if (err)
goto badkey;
break;
case MTK_CRYPTO_ALG_SHA224:
if (mtk_crypto_hmac_setkey("crypto-eip-sha224", keys.authkey,
keys.authkeylen, &istate, &ostate))
goto badkey;
break;
case MTK_CRYPTO_ALG_SHA256:
if (mtk_crypto_hmac_setkey("crypto-eip-sha256", keys.authkey,
keys.authkeylen, &istate, &ostate))
goto badkey;
break;
case MTK_CRYPTO_ALG_SHA384:
if (mtk_crypto_hmac_setkey("crypto-eip-sha384", keys.authkey,
keys.authkeylen, &istate, &ostate))
goto badkey;
break;
case MTK_CRYPTO_ALG_SHA512:
if (mtk_crypto_hmac_setkey("crypto-eip-sha512", keys.authkey,
keys.authkeylen, &istate, &ostate))
goto badkey;
break;
case MTK_CRYPTO_ALG_MD5:
if (mtk_crypto_hmac_setkey("crypto-eip-md5", keys.authkey,
keys.authkeylen, &istate, &ostate))
goto badkey;
break;
default:
CRYPTO_ERR("aead: unsupported hash algorithm\n");
goto badkey;
}
for (i = 0; i < keys.enckeylen / sizeof(u32); i++)
ctx->key[i] = cpu_to_le32(((u32 *)keys.enckey)[i]);
ctx->key_len = keys.enckeylen;
memcpy(ctx->ipad, &istate.state, ctx->state_sz);
memcpy(ctx->opad, &ostate.state, ctx->state_sz);
if (istate.sa_pointer)
crypto_free_sa(istate.sa_pointer);
kfree(istate.token_context);
if (ostate.sa_pointer)
crypto_free_sa(ostate.sa_pointer);
kfree(ostate.token_context);
memzero_explicit(&keys, sizeof(keys));
return 0;
badkey:
memzero_explicit(&keys, sizeof(keys));
return err;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha1_cbc_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = AES_BLOCK_SIZE,
.maxauthsize = SHA1_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha1),cbc(aes))",
.cra_driver_name = "crypto-eip-hmac-sha1-cbc-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha1_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha224_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_cra_init(tfm);
ctx->hash_alg = MTK_CRYPTO_ALG_SHA224;
ctx->state_sz = SHA256_DIGEST_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha224_cbc_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = AES_BLOCK_SIZE,
.maxauthsize = SHA224_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha224),cbc(aes))",
.cra_driver_name = "crypto-eip-hmac-sha224-cbc-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha224_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha256_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_cra_init(tfm);
ctx->hash_alg = MTK_CRYPTO_ALG_SHA256;
ctx->state_sz = SHA256_DIGEST_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha256_cbc_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = AES_BLOCK_SIZE,
.maxauthsize = SHA256_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha256),cbc(aes))",
.cra_driver_name = "crypto-eip-hmac-sha256-cbc-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha256_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha384_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_cra_init(tfm);
ctx->hash_alg = MTK_CRYPTO_ALG_SHA384;
ctx->state_sz = SHA512_DIGEST_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha384_cbc_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = AES_BLOCK_SIZE,
.maxauthsize = SHA384_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha384),cbc(aes))",
.cra_driver_name = "crypto-eip-hmac-sha384-cbc-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha384_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha512_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_cra_init(tfm);
ctx->hash_alg = MTK_CRYPTO_ALG_SHA512;
ctx->state_sz = SHA512_DIGEST_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha512_cbc_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = AES_BLOCK_SIZE,
.maxauthsize = SHA512_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha512),cbc(aes))",
.cra_driver_name = "crypto-eip-hmac-sha512-cbc-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha512_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_md5_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_cra_init(tfm);
ctx->hash_alg = MTK_CRYPTO_ALG_MD5;
ctx->state_sz = MD5_DIGEST_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_md5_cbc_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = AES_BLOCK_SIZE,
.maxauthsize = SHA512_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(md5),cbc(aes))",
.cra_driver_name = "crypto-eip-hmac-md5-cbc-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_md5_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha1_des3_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha1_cra_init(tfm);
ctx->alg = MTK_CRYPTO_3DES;
ctx->blocksz = DES3_EDE_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha1_cbc_des3_ede = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES3_EDE_BLOCK_SIZE,
.maxauthsize = SHA1_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha1),cbc(des3_ede))",
.cra_driver_name = "crypto-eip-hmac-sha1-cbc-des3_ede",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha1_des3_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha224_des3_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha224_cra_init(tfm);
ctx->alg = MTK_CRYPTO_3DES;
ctx->blocksz = DES3_EDE_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha224_cbc_des3_ede = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES3_EDE_BLOCK_SIZE,
.maxauthsize = SHA224_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha224),cbc(des3_ede))",
.cra_driver_name = "crypto-eip-hmac-sha224-cbc-des3_ede",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha224_des3_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha256_des3_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha256_cra_init(tfm);
ctx->alg = MTK_CRYPTO_3DES;
ctx->blocksz = DES3_EDE_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha256_cbc_des3_ede = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES3_EDE_BLOCK_SIZE,
.maxauthsize = SHA256_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha256),cbc(des3_ede))",
.cra_driver_name = "crypto-eip-hmac-sha256-cbc-des3_ede",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha256_des3_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha384_des3_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha384_cra_init(tfm);
ctx->alg = MTK_CRYPTO_3DES;
ctx->blocksz = DES3_EDE_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha384_cbc_des3_ede = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES3_EDE_BLOCK_SIZE,
.maxauthsize = SHA384_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha384),cbc(des3_ede))",
.cra_driver_name = "crypto-eip-hmac-sha384-cbc-des3_ede",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha384_des3_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha512_des3_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha512_cra_init(tfm);
ctx->alg = MTK_CRYPTO_3DES;
ctx->blocksz = DES3_EDE_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha512_cbc_des3_ede = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES3_EDE_BLOCK_SIZE,
.maxauthsize = SHA512_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha512),cbc(des3_ede))",
.cra_driver_name = "crypto-eip-hmac-sha512-cbc-des3_ede",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha512_des3_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_md5_des3_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_md5_cra_init(tfm);
ctx->alg = MTK_CRYPTO_3DES;
ctx->blocksz = DES3_EDE_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_md5_cbc_des3_ede = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES3_EDE_BLOCK_SIZE,
.maxauthsize = MD5_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(md5),cbc(des3_ede))",
.cra_driver_name = "crypto-eip-hmac-md5-cbc-des3_ede",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_md5_des3_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha1_des_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha1_cra_init(tfm);
ctx->alg = MTK_CRYPTO_DES;
ctx->blocksz = DES_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha1_cbc_des = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES_BLOCK_SIZE,
.maxauthsize = SHA1_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha1),cbc(des))",
.cra_driver_name = "crypto-eip-hmac-sha1-cbc-des",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha1_des_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha224_des_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha224_cra_init(tfm);
ctx->alg = MTK_CRYPTO_DES;
ctx->blocksz = DES_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha224_cbc_des = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES_BLOCK_SIZE,
.maxauthsize = SHA224_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha224),cbc(des))",
.cra_driver_name = "crypto-eip-hmac-sha224-cbc-des",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha224_des_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha256_des_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha256_cra_init(tfm);
ctx->alg = MTK_CRYPTO_DES;
ctx->blocksz = DES_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha256_cbc_des = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES_BLOCK_SIZE,
.maxauthsize = SHA256_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha256),cbc(des))",
.cra_driver_name = "crypto-eip-hmac-sha256-cbc-des",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha256_des_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha384_des_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha384_cra_init(tfm);
ctx->alg = MTK_CRYPTO_DES;
ctx->blocksz = DES_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha384_cbc_des = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES_BLOCK_SIZE,
.maxauthsize = SHA384_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha384),cbc(des))",
.cra_driver_name = "crypto-eip-hmac-sha384-cbc-des",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha384_des_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha512_des_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha512_cra_init(tfm);
ctx->alg = MTK_CRYPTO_DES;
ctx->blocksz = DES_BLOCK_SIZE;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha512_cbc_des = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = DES_BLOCK_SIZE,
.maxauthsize = SHA512_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha512),cbc(des))",
.cra_driver_name = "crypto-eip-hmac-sha512-cbc-des",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = DES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha512_des_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha1_ctr_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha1_cra_init(tfm);
ctx->mode = MTK_CRYPTO_MODE_CTR;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha1_ctr_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = CTR_RFC3686_IV_SIZE,
.maxauthsize = SHA1_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
.cra_driver_name = "crypto-eip-hmac-sha1-ctr-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha1_ctr_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha256_ctr_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha256_cra_init(tfm);
ctx->mode = MTK_CRYPTO_MODE_CTR;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha256_ctr_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = CTR_RFC3686_IV_SIZE,
.maxauthsize = SHA256_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
.cra_driver_name = "crypto-eip-hmac-sha256-ctr-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha256_ctr_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha224_ctr_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha224_cra_init(tfm);
ctx->mode = MTK_CRYPTO_MODE_CTR;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha224_ctr_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = CTR_RFC3686_IV_SIZE,
.maxauthsize = SHA224_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha224),rfc3686(ctr(aes)))",
.cra_driver_name = "crypto-eip-hmac-sha224-ctr-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha224_ctr_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_sha512_ctr_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_sha512_cra_init(tfm);
ctx->mode = MTK_CRYPTO_MODE_CTR;
return 0;
}
struct mtk_crypto_alg_template mtk_crypto_hmac_sha512_ctr_aes = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_setkey,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = CTR_RFC3686_IV_SIZE,
.maxauthsize = SHA512_DIGEST_SIZE,
.base = {
.cra_name = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
.cra_driver_name = "crypto-eip-hmac-sha512-ctr-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_sha512_ctr_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_aead_gcm_setkey(struct crypto_aead *ctfm, const u8 *key,
unsigned int len)
{
struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct crypto_aes_ctx aes;
u32 hashkey[AES_BLOCK_SIZE >> 2];
int ret, i;
ret = aes_expandkey(&aes, key, len);
if (ret) {
memzero_explicit(&aes, sizeof(aes));
return ret;
}
for (i = 0; i < len / sizeof(u32); i++)
ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
ctx->key_len = len;
/* Compute hash key by encrypting zeros with cipher key */
crypto_cipher_clear_flags(ctx->hkaes, CRYPTO_TFM_REQ_MASK);
crypto_cipher_set_flags(ctx->hkaes, crypto_aead_get_flags(ctfm) &
CRYPTO_TFM_REQ_MASK);
ret = crypto_cipher_setkey(ctx->hkaes, key, len);
if (ret)
return ret;
memset(hashkey, 0, AES_BLOCK_SIZE);
crypto_cipher_encrypt_one(ctx->hkaes, (u8 *)hashkey, (u8 *)hashkey);
for (i = 0; i < AES_BLOCK_SIZE / sizeof(u32); i++)
ctx->ipad[i] = cpu_to_be32(hashkey[i]);
memzero_explicit(hashkey, AES_BLOCK_SIZE);
memzero_explicit(&aes, sizeof(aes));
return 0;
}
static int mtk_crypto_aead_gcm_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_cra_init(tfm);
ctx->hash_alg = MTK_CRYPTO_ALG_GCM;
ctx->state_sz = GHASH_BLOCK_SIZE;
ctx->mode = MTK_CRYPTO_MODE_GCM;
ctx->hkaes = crypto_alloc_cipher("aes", 0, 0);
return PTR_ERR_OR_ZERO(ctx->hkaes);
}
static void mtk_crypto_aead_gcm_cra_exit(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
crypto_free_cipher(ctx->hkaes);
mtk_crypto_aead_cra_exit(tfm);
}
static int mtk_crypto_aead_gcm_setauthsize(struct crypto_aead *tfm,
unsigned int authsize)
{
return crypto_gcm_check_authsize(authsize);
}
struct mtk_crypto_alg_template mtk_crypto_gcm = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_aead_gcm_setkey,
.setauthsize = mtk_crypto_aead_gcm_setauthsize,
.encrypt = mtk_crypto_aead_encrypt,
.decrypt = mtk_crypto_aead_decrypt,
.ivsize = GCM_AES_IV_SIZE,
.maxauthsize = GHASH_DIGEST_SIZE,
.base = {
.cra_name = "gcm(aes)",
.cra_driver_name = "crypto-eip-gcm-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_aead_gcm_cra_init,
.cra_exit = mtk_crypto_aead_gcm_cra_exit,
.cra_module = THIS_MODULE,
},
},
};
static int mtk_crypto_rfc4106_gcm_setkey(struct crypto_aead *ctfm, const u8 *key,
unsigned int len)
{
struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
/* last 4 bytes of key are the nonce! */
ctx->nonce = *(u32 *)(key + len - CTR_RFC3686_NONCE_SIZE);
len -= CTR_RFC3686_NONCE_SIZE;
return mtk_crypto_aead_gcm_setkey(ctfm, key, len);
}
static int mtk_crypto_rfc4106_gcm_setauthsize(struct crypto_aead *tfm,
unsigned int authsize)
{
return crypto_rfc4106_check_authsize(authsize);
}
static int mtk_crypto_rfc4106_encrypt(struct aead_request *req)
{
return crypto_ipsec_check_assoclen(req->assoclen) ?:
mtk_crypto_aead_encrypt(req);
}
static int mtk_crypto_rfc4106_decrypt(struct aead_request *req)
{
return crypto_ipsec_check_assoclen(req->assoclen) ?:
mtk_crypto_aead_decrypt(req);
}
static int mtk_crypto_rfc4106_gcm_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
int ret;
ret = mtk_crypto_aead_gcm_cra_init(tfm);
ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP;
return ret;
}
struct mtk_crypto_alg_template mtk_crypto_rfc4106_gcm = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_rfc4106_gcm_setkey,
.setauthsize = mtk_crypto_rfc4106_gcm_setauthsize,
.encrypt = mtk_crypto_rfc4106_encrypt,
.decrypt = mtk_crypto_rfc4106_decrypt,
.ivsize = GCM_RFC4106_IV_SIZE,
.maxauthsize = GHASH_DIGEST_SIZE,
.base = {
.cra_name = "rfc4106(gcm(aes))",
.cra_driver_name = "crypto-eip-rfc4106-gcm-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_rfc4106_gcm_cra_init,
.cra_exit = mtk_crypto_aead_gcm_cra_exit,
},
},
};
static int mtk_crypto_rfc4543_gcm_setauthsize(struct crypto_aead *tfm,
unsigned int authsize)
{
if (authsize != GHASH_DIGEST_SIZE)
return -EINVAL;
return 0;
}
static int mtk_crypto_rfc4543_gcm_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
int ret;
ret = mtk_crypto_aead_gcm_cra_init(tfm);
ctx->hash_alg = MTK_CRYPTO_ALG_GMAC;
ctx->mode = MTK_CRYPTO_MODE_GMAC;
ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP;
return ret;
}
struct mtk_crypto_alg_template mtk_crypto_rfc4543_gcm = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_rfc4106_gcm_setkey,
.setauthsize = mtk_crypto_rfc4543_gcm_setauthsize,
.encrypt = mtk_crypto_rfc4106_encrypt,
.decrypt = mtk_crypto_rfc4106_decrypt,
.ivsize = GCM_RFC4543_IV_SIZE,
.maxauthsize = GHASH_DIGEST_SIZE,
.base = {
.cra_name = "rfc4543(gcm(aes))",
.cra_driver_name = "crypto-eip-rfc4543-gcm-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_rfc4543_gcm_cra_init,
.cra_exit = mtk_crypto_aead_gcm_cra_exit,
},
},
};
static int mtk_crypto_aead_ccm_setkey(struct crypto_aead *ctfm, const u8 *key,
unsigned int len)
{
struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct crypto_aes_ctx aes;
int ret, i;
ret = aes_expandkey(&aes, key, len);
if (ret) {
memzero_explicit(&aes, sizeof(aes));
return ret;
}
for (i = 0; i < len / sizeof(u32); i++) {
ctx->key[i] = cpu_to_le32(aes.key_enc[i]);
ctx->ipad[i + 2 * AES_BLOCK_SIZE / sizeof(u32)] =
cpu_to_be32(aes.key_enc[i]);
}
ctx->key_len = len;
ctx->state_sz = 2 * AES_BLOCK_SIZE + len;
ctx->hash_alg = MTK_CRYPTO_ALG_CCM;
memzero_explicit(&aes, sizeof(aes));
return 0;
}
static int mtk_crypto_rfc4309_ccm_setkey(struct crypto_aead *ctfm, const u8 *key,
unsigned int len)
{
struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
*(u8 *) &ctx->nonce = 3;
memcpy((u8 *) &ctx->nonce + 1, key + len -
EIP197_AEAD_IPSEC_CCM_NONCE_SIZE,
EIP197_AEAD_IPSEC_CCM_NONCE_SIZE);
len -= EIP197_AEAD_IPSEC_CCM_NONCE_SIZE;
return mtk_crypto_aead_ccm_setkey(ctfm, key, len);
}
static int mtk_crypto_rfc4309_ccm_setauthsize(struct crypto_aead *tfm,
unsigned int authsize)
{
switch (authsize) {
case 8:
case 12:
case 16:
break;
default:
return -EINVAL;
}
return 0;
}
static int mtk_crypto_rfc4309_ccm_encrypt(struct aead_request *req)
{
struct mtk_crypto_cipher_req *creq = aead_request_ctx(req);
if (req->assoclen != 16 && req->assoclen != 20)
return -EINVAL;
return mtk_crypto_queue_req(&req->base, creq, MTK_CRYPTO_ENCRYPT);
}
static int mtk_crypto_rfc4309_ccm_decrypt(struct aead_request *req)
{
struct mtk_crypto_cipher_req *creq = aead_request_ctx(req);
if (req->assoclen != 16 && req->assoclen != 20)
return -EINVAL;
return mtk_crypto_queue_req(&req->base, creq, MTK_CRYPTO_DECRYPT);
}
static int mtk_crypto_aead_ccm_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
mtk_crypto_aead_cra_init(tfm);
ctx->hash_alg = MTK_CRYPTO_ALG_XCBC;
ctx->state_sz = 3 * AES_BLOCK_SIZE;
ctx->mode = MTK_CRYPTO_MODE_CCM;
return 0;
}
static int mtk_crypto_rfc4309_ccm_cra_init(struct crypto_tfm *tfm)
{
struct mtk_crypto_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
int ret;
ret = mtk_crypto_aead_ccm_cra_init(tfm);
ctx->aead = EIP197_AEAD_TYPE_IPSEC_ESP;
return ret;
}
struct mtk_crypto_alg_template mtk_crypto_rfc4309_ccm = {
.type = MTK_CRYPTO_ALG_TYPE_AEAD,
.alg.aead = {
.setkey = mtk_crypto_rfc4309_ccm_setkey,
.setauthsize = mtk_crypto_rfc4309_ccm_setauthsize,
.encrypt = mtk_crypto_rfc4309_ccm_encrypt,
.decrypt = mtk_crypto_rfc4309_ccm_decrypt,
.ivsize = EIP197_AEAD_IPSEC_IV_SIZE,
.maxauthsize = AES_BLOCK_SIZE,
.base = {
.cra_name = "rfc4309(ccm(aes))",
.cra_driver_name = "crypto-eip-rfc4309-ccm-aes",
.cra_priority = MTK_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_ASYNC |
CRYPTO_ALG_KERN_DRIVER_ONLY,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct mtk_crypto_cipher_ctx),
.cra_alignmask = 0,
.cra_init = mtk_crypto_rfc4309_ccm_cra_init,
.cra_exit = mtk_crypto_aead_cra_exit,
.cra_module = THIS_MODULE,
},
},
};