mirror of
https://github.com/torvalds/linux.git
synced 2026-04-19 23:34:00 -04:00
bf4afc53b7
This was done entirely with mindless brute force, using
git grep -l '\<k[vmz]*alloc_objs*(.*, GFP_KERNEL)' |
xargs sed -i 's/\(alloc_objs*(.*\), GFP_KERNEL)/\1)/'
to convert the new alloc_obj() users that had a simple GFP_KERNEL
argument to just drop that argument.
Note that due to the extreme simplicity of the scripting, any slightly
more complex cases spread over multiple lines would not be triggered:
they definitely exist, but this covers the vast bulk of the cases, and
the resulting diff is also then easier to check automatically.
For the same reason the 'flex' versions will be done as a separate
conversion.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
414 lines
11 KiB
C
414 lines
11 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2019 - 2021
|
|
*
|
|
* Richard van Schagen <vschagen@icloud.com>
|
|
* Christian Marangi <ansuelsmth@gmail.com
|
|
*/
|
|
|
|
#include <crypto/aes.h>
|
|
#include <crypto/ctr.h>
|
|
#include <crypto/internal/des.h>
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include "eip93-aes.h"
|
|
#include "eip93-cipher.h"
|
|
#include "eip93-common.h"
|
|
#include "eip93-des.h"
|
|
#include "eip93-regs.h"
|
|
|
|
void eip93_skcipher_handle_result(struct crypto_async_request *async, int err)
|
|
{
|
|
struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(async->tfm);
|
|
struct eip93_device *eip93 = ctx->eip93;
|
|
struct skcipher_request *req = skcipher_request_cast(async);
|
|
struct eip93_cipher_reqctx *rctx = skcipher_request_ctx(req);
|
|
|
|
eip93_unmap_dma(eip93, rctx, req->src, req->dst);
|
|
eip93_handle_result(eip93, rctx, req->iv);
|
|
|
|
skcipher_request_complete(req, err);
|
|
}
|
|
|
|
static int eip93_skcipher_send_req(struct crypto_async_request *async)
|
|
{
|
|
struct skcipher_request *req = skcipher_request_cast(async);
|
|
struct eip93_cipher_reqctx *rctx = skcipher_request_ctx(req);
|
|
int err;
|
|
|
|
err = check_valid_request(rctx);
|
|
|
|
if (err) {
|
|
skcipher_request_complete(req, err);
|
|
return err;
|
|
}
|
|
|
|
return eip93_send_req(async, req->iv, rctx);
|
|
}
|
|
|
|
/* Crypto skcipher API functions */
|
|
static int eip93_skcipher_cra_init(struct crypto_tfm *tfm)
|
|
{
|
|
struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(tfm);
|
|
struct eip93_alg_template *tmpl = container_of(tfm->__crt_alg,
|
|
struct eip93_alg_template, alg.skcipher.base);
|
|
|
|
crypto_skcipher_set_reqsize(__crypto_skcipher_cast(tfm),
|
|
sizeof(struct eip93_cipher_reqctx));
|
|
|
|
memset(ctx, 0, sizeof(*ctx));
|
|
|
|
ctx->eip93 = tmpl->eip93;
|
|
ctx->type = tmpl->type;
|
|
|
|
ctx->sa_record = kzalloc_obj(*ctx->sa_record);
|
|
if (!ctx->sa_record)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void eip93_skcipher_cra_exit(struct crypto_tfm *tfm)
|
|
{
|
|
struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(tfm);
|
|
|
|
dma_unmap_single(ctx->eip93->dev, ctx->sa_record_base,
|
|
sizeof(*ctx->sa_record), DMA_TO_DEVICE);
|
|
kfree(ctx->sa_record);
|
|
}
|
|
|
|
static int eip93_skcipher_setkey(struct crypto_skcipher *ctfm, const u8 *key,
|
|
unsigned int len)
|
|
{
|
|
struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
|
|
struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(tfm);
|
|
struct eip93_alg_template *tmpl = container_of(tfm->__crt_alg,
|
|
struct eip93_alg_template,
|
|
alg.skcipher.base);
|
|
struct sa_record *sa_record = ctx->sa_record;
|
|
unsigned int keylen = len;
|
|
u32 flags = tmpl->flags;
|
|
u32 nonce = 0;
|
|
int ret;
|
|
|
|
if (!key || !keylen)
|
|
return -EINVAL;
|
|
|
|
if (IS_RFC3686(flags)) {
|
|
if (len < CTR_RFC3686_NONCE_SIZE)
|
|
return -EINVAL;
|
|
|
|
keylen = len - CTR_RFC3686_NONCE_SIZE;
|
|
memcpy(&nonce, key + keylen, CTR_RFC3686_NONCE_SIZE);
|
|
}
|
|
|
|
if (flags & EIP93_ALG_DES) {
|
|
ctx->blksize = DES_BLOCK_SIZE;
|
|
ret = verify_skcipher_des_key(ctfm, key);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
if (flags & EIP93_ALG_3DES) {
|
|
ctx->blksize = DES3_EDE_BLOCK_SIZE;
|
|
ret = verify_skcipher_des3_key(ctfm, key);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
if (flags & EIP93_ALG_AES) {
|
|
struct crypto_aes_ctx aes;
|
|
|
|
ctx->blksize = AES_BLOCK_SIZE;
|
|
ret = aes_expandkey(&aes, key, keylen);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
eip93_set_sa_record(sa_record, keylen, flags);
|
|
|
|
memcpy(sa_record->sa_key, key, keylen);
|
|
ctx->sa_nonce = nonce;
|
|
sa_record->sa_nonce = nonce;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int eip93_skcipher_crypt(struct skcipher_request *req)
|
|
{
|
|
struct eip93_cipher_reqctx *rctx = skcipher_request_ctx(req);
|
|
struct crypto_async_request *async = &req->base;
|
|
struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
|
|
struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
|
|
int ret;
|
|
|
|
if (!req->cryptlen)
|
|
return 0;
|
|
|
|
/*
|
|
* ECB and CBC algorithms require message lengths to be
|
|
* multiples of block size.
|
|
*/
|
|
if (IS_ECB(rctx->flags) || IS_CBC(rctx->flags))
|
|
if (!IS_ALIGNED(req->cryptlen,
|
|
crypto_skcipher_blocksize(skcipher)))
|
|
return -EINVAL;
|
|
|
|
ctx->sa_record_base = dma_map_single(ctx->eip93->dev, ctx->sa_record,
|
|
sizeof(*ctx->sa_record), DMA_TO_DEVICE);
|
|
ret = dma_mapping_error(ctx->eip93->dev, ctx->sa_record_base);
|
|
if (ret)
|
|
return ret;
|
|
|
|
rctx->assoclen = 0;
|
|
rctx->textsize = req->cryptlen;
|
|
rctx->authsize = 0;
|
|
rctx->sg_src = req->src;
|
|
rctx->sg_dst = req->dst;
|
|
rctx->ivsize = crypto_skcipher_ivsize(skcipher);
|
|
rctx->blksize = ctx->blksize;
|
|
rctx->desc_flags = EIP93_DESC_SKCIPHER;
|
|
rctx->sa_record_base = ctx->sa_record_base;
|
|
|
|
return eip93_skcipher_send_req(async);
|
|
}
|
|
|
|
static int eip93_skcipher_encrypt(struct skcipher_request *req)
|
|
{
|
|
struct eip93_cipher_reqctx *rctx = skcipher_request_ctx(req);
|
|
struct eip93_alg_template *tmpl = container_of(req->base.tfm->__crt_alg,
|
|
struct eip93_alg_template, alg.skcipher.base);
|
|
|
|
rctx->flags = tmpl->flags;
|
|
rctx->flags |= EIP93_ENCRYPT;
|
|
|
|
return eip93_skcipher_crypt(req);
|
|
}
|
|
|
|
static int eip93_skcipher_decrypt(struct skcipher_request *req)
|
|
{
|
|
struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
|
|
struct eip93_cipher_reqctx *rctx = skcipher_request_ctx(req);
|
|
struct eip93_alg_template *tmpl = container_of(req->base.tfm->__crt_alg,
|
|
struct eip93_alg_template, alg.skcipher.base);
|
|
|
|
ctx->sa_record->sa_cmd0_word |= EIP93_SA_CMD_DIRECTION_IN;
|
|
|
|
rctx->flags = tmpl->flags;
|
|
rctx->flags |= EIP93_DECRYPT;
|
|
|
|
return eip93_skcipher_crypt(req);
|
|
}
|
|
|
|
/* Available algorithms in this module */
|
|
struct eip93_alg_template eip93_alg_ecb_aes = {
|
|
.type = EIP93_ALG_TYPE_SKCIPHER,
|
|
.flags = EIP93_MODE_ECB | EIP93_ALG_AES,
|
|
.alg.skcipher = {
|
|
.setkey = eip93_skcipher_setkey,
|
|
.encrypt = eip93_skcipher_encrypt,
|
|
.decrypt = eip93_skcipher_decrypt,
|
|
.min_keysize = AES_MIN_KEY_SIZE,
|
|
.max_keysize = AES_MAX_KEY_SIZE,
|
|
.ivsize = 0,
|
|
.base = {
|
|
.cra_name = "ecb(aes)",
|
|
.cra_driver_name = "ecb(aes-eip93)",
|
|
.cra_priority = EIP93_CRA_PRIORITY,
|
|
.cra_flags = CRYPTO_ALG_ASYNC |
|
|
CRYPTO_ALG_NEED_FALLBACK |
|
|
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
|
.cra_blocksize = AES_BLOCK_SIZE,
|
|
.cra_ctxsize = sizeof(struct eip93_crypto_ctx),
|
|
.cra_alignmask = 0xf,
|
|
.cra_init = eip93_skcipher_cra_init,
|
|
.cra_exit = eip93_skcipher_cra_exit,
|
|
.cra_module = THIS_MODULE,
|
|
},
|
|
},
|
|
};
|
|
|
|
struct eip93_alg_template eip93_alg_cbc_aes = {
|
|
.type = EIP93_ALG_TYPE_SKCIPHER,
|
|
.flags = EIP93_MODE_CBC | EIP93_ALG_AES,
|
|
.alg.skcipher = {
|
|
.setkey = eip93_skcipher_setkey,
|
|
.encrypt = eip93_skcipher_encrypt,
|
|
.decrypt = eip93_skcipher_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 = "cbc(aes-eip93)",
|
|
.cra_priority = EIP93_CRA_PRIORITY,
|
|
.cra_flags = CRYPTO_ALG_ASYNC |
|
|
CRYPTO_ALG_NEED_FALLBACK |
|
|
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
|
.cra_blocksize = AES_BLOCK_SIZE,
|
|
.cra_ctxsize = sizeof(struct eip93_crypto_ctx),
|
|
.cra_alignmask = 0xf,
|
|
.cra_init = eip93_skcipher_cra_init,
|
|
.cra_exit = eip93_skcipher_cra_exit,
|
|
.cra_module = THIS_MODULE,
|
|
},
|
|
},
|
|
};
|
|
|
|
struct eip93_alg_template eip93_alg_ctr_aes = {
|
|
.type = EIP93_ALG_TYPE_SKCIPHER,
|
|
.flags = EIP93_MODE_CTR | EIP93_ALG_AES,
|
|
.alg.skcipher = {
|
|
.setkey = eip93_skcipher_setkey,
|
|
.encrypt = eip93_skcipher_encrypt,
|
|
.decrypt = eip93_skcipher_decrypt,
|
|
.min_keysize = AES_MIN_KEY_SIZE,
|
|
.max_keysize = AES_MAX_KEY_SIZE,
|
|
.ivsize = AES_BLOCK_SIZE,
|
|
.base = {
|
|
.cra_name = "ctr(aes)",
|
|
.cra_driver_name = "ctr(aes-eip93)",
|
|
.cra_priority = EIP93_CRA_PRIORITY,
|
|
.cra_flags = CRYPTO_ALG_ASYNC |
|
|
CRYPTO_ALG_NEED_FALLBACK |
|
|
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
|
.cra_blocksize = 1,
|
|
.cra_ctxsize = sizeof(struct eip93_crypto_ctx),
|
|
.cra_alignmask = 0xf,
|
|
.cra_init = eip93_skcipher_cra_init,
|
|
.cra_exit = eip93_skcipher_cra_exit,
|
|
.cra_module = THIS_MODULE,
|
|
},
|
|
},
|
|
};
|
|
|
|
struct eip93_alg_template eip93_alg_rfc3686_aes = {
|
|
.type = EIP93_ALG_TYPE_SKCIPHER,
|
|
.flags = EIP93_MODE_CTR | EIP93_MODE_RFC3686 | EIP93_ALG_AES,
|
|
.alg.skcipher = {
|
|
.setkey = eip93_skcipher_setkey,
|
|
.encrypt = eip93_skcipher_encrypt,
|
|
.decrypt = eip93_skcipher_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 = "rfc3686(ctr(aes-eip93))",
|
|
.cra_priority = EIP93_CRA_PRIORITY,
|
|
.cra_flags = CRYPTO_ALG_ASYNC |
|
|
CRYPTO_ALG_NEED_FALLBACK |
|
|
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
|
.cra_blocksize = 1,
|
|
.cra_ctxsize = sizeof(struct eip93_crypto_ctx),
|
|
.cra_alignmask = 0xf,
|
|
.cra_init = eip93_skcipher_cra_init,
|
|
.cra_exit = eip93_skcipher_cra_exit,
|
|
.cra_module = THIS_MODULE,
|
|
},
|
|
},
|
|
};
|
|
|
|
struct eip93_alg_template eip93_alg_ecb_des = {
|
|
.type = EIP93_ALG_TYPE_SKCIPHER,
|
|
.flags = EIP93_MODE_ECB | EIP93_ALG_DES,
|
|
.alg.skcipher = {
|
|
.setkey = eip93_skcipher_setkey,
|
|
.encrypt = eip93_skcipher_encrypt,
|
|
.decrypt = eip93_skcipher_decrypt,
|
|
.min_keysize = DES_KEY_SIZE,
|
|
.max_keysize = DES_KEY_SIZE,
|
|
.ivsize = 0,
|
|
.base = {
|
|
.cra_name = "ecb(des)",
|
|
.cra_driver_name = "ebc(des-eip93)",
|
|
.cra_priority = EIP93_CRA_PRIORITY,
|
|
.cra_flags = CRYPTO_ALG_ASYNC |
|
|
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
|
.cra_blocksize = DES_BLOCK_SIZE,
|
|
.cra_ctxsize = sizeof(struct eip93_crypto_ctx),
|
|
.cra_alignmask = 0,
|
|
.cra_init = eip93_skcipher_cra_init,
|
|
.cra_exit = eip93_skcipher_cra_exit,
|
|
.cra_module = THIS_MODULE,
|
|
},
|
|
},
|
|
};
|
|
|
|
struct eip93_alg_template eip93_alg_cbc_des = {
|
|
.type = EIP93_ALG_TYPE_SKCIPHER,
|
|
.flags = EIP93_MODE_CBC | EIP93_ALG_DES,
|
|
.alg.skcipher = {
|
|
.setkey = eip93_skcipher_setkey,
|
|
.encrypt = eip93_skcipher_encrypt,
|
|
.decrypt = eip93_skcipher_decrypt,
|
|
.min_keysize = DES_KEY_SIZE,
|
|
.max_keysize = DES_KEY_SIZE,
|
|
.ivsize = DES_BLOCK_SIZE,
|
|
.base = {
|
|
.cra_name = "cbc(des)",
|
|
.cra_driver_name = "cbc(des-eip93)",
|
|
.cra_priority = EIP93_CRA_PRIORITY,
|
|
.cra_flags = CRYPTO_ALG_ASYNC |
|
|
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
|
.cra_blocksize = DES_BLOCK_SIZE,
|
|
.cra_ctxsize = sizeof(struct eip93_crypto_ctx),
|
|
.cra_alignmask = 0,
|
|
.cra_init = eip93_skcipher_cra_init,
|
|
.cra_exit = eip93_skcipher_cra_exit,
|
|
.cra_module = THIS_MODULE,
|
|
},
|
|
},
|
|
};
|
|
|
|
struct eip93_alg_template eip93_alg_ecb_des3_ede = {
|
|
.type = EIP93_ALG_TYPE_SKCIPHER,
|
|
.flags = EIP93_MODE_ECB | EIP93_ALG_3DES,
|
|
.alg.skcipher = {
|
|
.setkey = eip93_skcipher_setkey,
|
|
.encrypt = eip93_skcipher_encrypt,
|
|
.decrypt = eip93_skcipher_decrypt,
|
|
.min_keysize = DES3_EDE_KEY_SIZE,
|
|
.max_keysize = DES3_EDE_KEY_SIZE,
|
|
.ivsize = 0,
|
|
.base = {
|
|
.cra_name = "ecb(des3_ede)",
|
|
.cra_driver_name = "ecb(des3_ede-eip93)",
|
|
.cra_priority = EIP93_CRA_PRIORITY,
|
|
.cra_flags = CRYPTO_ALG_ASYNC |
|
|
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
|
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
|
|
.cra_ctxsize = sizeof(struct eip93_crypto_ctx),
|
|
.cra_alignmask = 0,
|
|
.cra_init = eip93_skcipher_cra_init,
|
|
.cra_exit = eip93_skcipher_cra_exit,
|
|
.cra_module = THIS_MODULE,
|
|
},
|
|
},
|
|
};
|
|
|
|
struct eip93_alg_template eip93_alg_cbc_des3_ede = {
|
|
.type = EIP93_ALG_TYPE_SKCIPHER,
|
|
.flags = EIP93_MODE_CBC | EIP93_ALG_3DES,
|
|
.alg.skcipher = {
|
|
.setkey = eip93_skcipher_setkey,
|
|
.encrypt = eip93_skcipher_encrypt,
|
|
.decrypt = eip93_skcipher_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 = "cbc(des3_ede-eip93)",
|
|
.cra_priority = EIP93_CRA_PRIORITY,
|
|
.cra_flags = CRYPTO_ALG_ASYNC |
|
|
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
|
.cra_blocksize = DES3_EDE_BLOCK_SIZE,
|
|
.cra_ctxsize = sizeof(struct eip93_crypto_ctx),
|
|
.cra_alignmask = 0,
|
|
.cra_init = eip93_skcipher_cra_init,
|
|
.cra_exit = eip93_skcipher_cra_exit,
|
|
.cra_module = THIS_MODULE,
|
|
},
|
|
},
|
|
};
|