2019-05-27 00:55:01 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2013-04-08 01:48:44 -06:00
|
|
|
/*
|
|
|
|
* CMAC: Cipher Block Mode for Authentication
|
|
|
|
*
|
|
|
|
* Copyright © 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
|
|
|
|
*
|
|
|
|
* Based on work by:
|
|
|
|
* Copyright © 2013 Tom St Denis <tstdenis@elliptictech.com>
|
|
|
|
* Based on crypto/xcbc.c:
|
|
|
|
* Copyright © 2006 USAGI/WIDE Project,
|
|
|
|
* Author: Kazunori Miyazawa <miyazawa@linux-ipv6.org>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <crypto/internal/hash.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* +------------------------
|
|
|
|
* | <parent tfm>
|
|
|
|
* +------------------------
|
|
|
|
* | cmac_tfm_ctx
|
|
|
|
* +------------------------
|
|
|
|
* | consts (block size * 2)
|
|
|
|
* +------------------------
|
|
|
|
*/
|
|
|
|
struct cmac_tfm_ctx {
|
|
|
|
struct crypto_cipher *child;
|
|
|
|
u8 ctx[];
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* +------------------------
|
|
|
|
* | <shash desc>
|
|
|
|
* +------------------------
|
|
|
|
* | cmac_desc_ctx
|
|
|
|
* +------------------------
|
|
|
|
* | odds (block size)
|
|
|
|
* +------------------------
|
|
|
|
* | prev (block size)
|
|
|
|
* +------------------------
|
|
|
|
*/
|
|
|
|
struct cmac_desc_ctx {
|
|
|
|
unsigned int len;
|
|
|
|
u8 ctx[];
|
|
|
|
};
|
|
|
|
|
|
|
|
static int crypto_cmac_digest_setkey(struct crypto_shash *parent,
|
|
|
|
const u8 *inkey, unsigned int keylen)
|
|
|
|
{
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(parent);
|
|
|
|
struct cmac_tfm_ctx *ctx = crypto_shash_ctx(parent);
|
|
|
|
unsigned int bs = crypto_shash_blocksize(parent);
|
2016-10-10 11:15:15 -06:00
|
|
|
__be64 *consts = PTR_ALIGN((void *)ctx->ctx,
|
|
|
|
(alignmask | (__alignof__(__be64) - 1)) + 1);
|
2013-04-08 01:48:44 -06:00
|
|
|
u64 _const[2];
|
|
|
|
int i, err = 0;
|
|
|
|
u8 msb_mask, gfmask;
|
|
|
|
|
|
|
|
err = crypto_cipher_setkey(ctx->child, inkey, keylen);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* encrypt the zero block */
|
|
|
|
memset(consts, 0, bs);
|
|
|
|
crypto_cipher_encrypt_one(ctx->child, (u8 *)consts, (u8 *)consts);
|
|
|
|
|
|
|
|
switch (bs) {
|
|
|
|
case 16:
|
|
|
|
gfmask = 0x87;
|
|
|
|
_const[0] = be64_to_cpu(consts[1]);
|
|
|
|
_const[1] = be64_to_cpu(consts[0]);
|
|
|
|
|
|
|
|
/* gf(2^128) multiply zero-ciphertext with u and u^2 */
|
|
|
|
for (i = 0; i < 4; i += 2) {
|
|
|
|
msb_mask = ((s64)_const[1] >> 63) & gfmask;
|
|
|
|
_const[1] = (_const[1] << 1) | (_const[0] >> 63);
|
|
|
|
_const[0] = (_const[0] << 1) ^ msb_mask;
|
|
|
|
|
|
|
|
consts[i + 0] = cpu_to_be64(_const[1]);
|
|
|
|
consts[i + 1] = cpu_to_be64(_const[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
case 8:
|
|
|
|
gfmask = 0x1B;
|
|
|
|
_const[0] = be64_to_cpu(consts[0]);
|
|
|
|
|
|
|
|
/* gf(2^64) multiply zero-ciphertext with u and u^2 */
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
msb_mask = ((s64)_const[0] >> 63) & gfmask;
|
|
|
|
_const[0] = (_const[0] << 1) ^ msb_mask;
|
|
|
|
|
|
|
|
consts[i] = cpu_to_be64(_const[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypto_cmac_digest_init(struct shash_desc *pdesc)
|
|
|
|
{
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(pdesc->tfm);
|
|
|
|
struct cmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
|
|
|
|
int bs = crypto_shash_blocksize(pdesc->tfm);
|
|
|
|
u8 *prev = PTR_ALIGN((void *)ctx->ctx, alignmask + 1) + bs;
|
|
|
|
|
|
|
|
ctx->len = 0;
|
|
|
|
memset(prev, 0, bs);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypto_cmac_digest_update(struct shash_desc *pdesc, const u8 *p,
|
|
|
|
unsigned int len)
|
|
|
|
{
|
|
|
|
struct crypto_shash *parent = pdesc->tfm;
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(parent);
|
|
|
|
struct cmac_tfm_ctx *tctx = crypto_shash_ctx(parent);
|
|
|
|
struct cmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
|
|
|
|
struct crypto_cipher *tfm = tctx->child;
|
|
|
|
int bs = crypto_shash_blocksize(parent);
|
|
|
|
u8 *odds = PTR_ALIGN((void *)ctx->ctx, alignmask + 1);
|
|
|
|
u8 *prev = odds + bs;
|
|
|
|
|
|
|
|
/* checking the data can fill the block */
|
|
|
|
if ((ctx->len + len) <= bs) {
|
|
|
|
memcpy(odds + ctx->len, p, len);
|
|
|
|
ctx->len += len;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* filling odds with new data and encrypting it */
|
|
|
|
memcpy(odds + ctx->len, p, bs - ctx->len);
|
|
|
|
len -= bs - ctx->len;
|
|
|
|
p += bs - ctx->len;
|
|
|
|
|
|
|
|
crypto_xor(prev, odds, bs);
|
|
|
|
crypto_cipher_encrypt_one(tfm, prev, prev);
|
|
|
|
|
|
|
|
/* clearing the length */
|
|
|
|
ctx->len = 0;
|
|
|
|
|
|
|
|
/* encrypting the rest of data */
|
|
|
|
while (len > bs) {
|
|
|
|
crypto_xor(prev, p, bs);
|
|
|
|
crypto_cipher_encrypt_one(tfm, prev, prev);
|
|
|
|
p += bs;
|
|
|
|
len -= bs;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* keeping the surplus of blocksize */
|
|
|
|
if (len) {
|
|
|
|
memcpy(odds, p, len);
|
|
|
|
ctx->len = len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypto_cmac_digest_final(struct shash_desc *pdesc, u8 *out)
|
|
|
|
{
|
|
|
|
struct crypto_shash *parent = pdesc->tfm;
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(parent);
|
|
|
|
struct cmac_tfm_ctx *tctx = crypto_shash_ctx(parent);
|
|
|
|
struct cmac_desc_ctx *ctx = shash_desc_ctx(pdesc);
|
|
|
|
struct crypto_cipher *tfm = tctx->child;
|
|
|
|
int bs = crypto_shash_blocksize(parent);
|
2016-10-10 11:15:15 -06:00
|
|
|
u8 *consts = PTR_ALIGN((void *)tctx->ctx,
|
|
|
|
(alignmask | (__alignof__(__be64) - 1)) + 1);
|
2013-04-08 01:48:44 -06:00
|
|
|
u8 *odds = PTR_ALIGN((void *)ctx->ctx, alignmask + 1);
|
|
|
|
u8 *prev = odds + bs;
|
|
|
|
unsigned int offset = 0;
|
|
|
|
|
|
|
|
if (ctx->len != bs) {
|
|
|
|
unsigned int rlen;
|
|
|
|
u8 *p = odds + ctx->len;
|
|
|
|
|
|
|
|
*p = 0x80;
|
|
|
|
p++;
|
|
|
|
|
|
|
|
rlen = bs - ctx->len - 1;
|
|
|
|
if (rlen)
|
|
|
|
memset(p, 0, rlen);
|
|
|
|
|
|
|
|
offset += bs;
|
|
|
|
}
|
|
|
|
|
|
|
|
crypto_xor(prev, odds, bs);
|
|
|
|
crypto_xor(prev, consts + offset, bs);
|
|
|
|
|
|
|
|
crypto_cipher_encrypt_one(tfm, out, prev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmac_init_tfm(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
struct crypto_cipher *cipher;
|
|
|
|
struct crypto_instance *inst = (void *)tfm->__crt_alg;
|
2020-01-02 20:59:05 -07:00
|
|
|
struct crypto_cipher_spawn *spawn = crypto_instance_ctx(inst);
|
2013-04-08 01:48:44 -06:00
|
|
|
struct cmac_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
|
|
|
|
|
|
|
|
cipher = crypto_spawn_cipher(spawn);
|
|
|
|
if (IS_ERR(cipher))
|
|
|
|
return PTR_ERR(cipher);
|
|
|
|
|
|
|
|
ctx->child = cipher;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void cmac_exit_tfm(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
struct cmac_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
|
|
|
|
crypto_free_cipher(ctx->child);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmac_create(struct crypto_template *tmpl, struct rtattr **tb)
|
|
|
|
{
|
|
|
|
struct shash_instance *inst;
|
2020-01-02 20:59:02 -07:00
|
|
|
struct crypto_cipher_spawn *spawn;
|
2013-04-08 01:48:44 -06:00
|
|
|
struct crypto_alg *alg;
|
|
|
|
unsigned long alignmask;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SHASH);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2020-01-02 20:59:02 -07:00
|
|
|
inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
|
|
|
|
if (!inst)
|
|
|
|
return -ENOMEM;
|
|
|
|
spawn = shash_instance_ctx(inst);
|
|
|
|
|
|
|
|
err = crypto_grab_cipher(spawn, shash_crypto_instance(inst),
|
|
|
|
crypto_attr_alg_name(tb[1]), 0, 0);
|
|
|
|
if (err)
|
|
|
|
goto err_free_inst;
|
|
|
|
alg = crypto_spawn_cipher_alg(spawn);
|
2013-04-08 01:48:44 -06:00
|
|
|
|
|
|
|
switch (alg->cra_blocksize) {
|
|
|
|
case 16:
|
|
|
|
case 8:
|
|
|
|
break;
|
|
|
|
default:
|
2016-10-10 11:15:14 -06:00
|
|
|
err = -EINVAL;
|
2020-01-02 20:59:02 -07:00
|
|
|
goto err_free_inst;
|
2013-04-08 01:48:44 -06:00
|
|
|
}
|
|
|
|
|
2020-01-02 20:59:02 -07:00
|
|
|
err = crypto_inst_setname(shash_crypto_instance(inst), tmpl->name, alg);
|
2013-04-08 01:48:44 -06:00
|
|
|
if (err)
|
2020-01-02 20:59:02 -07:00
|
|
|
goto err_free_inst;
|
2013-04-08 01:48:44 -06:00
|
|
|
|
crypto: algapi - make crypto_xor() and crypto_inc() alignment agnostic
Instead of unconditionally forcing 4 byte alignment for all generic
chaining modes that rely on crypto_xor() or crypto_inc() (which may
result in unnecessary copying of data when the underlying hardware
can perform unaligned accesses efficiently), make those functions
deal with unaligned input explicitly, but only if the Kconfig symbol
HAVE_EFFICIENT_UNALIGNED_ACCESS is set. This will allow us to drop
the alignmasks from the CBC, CMAC, CTR, CTS, PCBC and SEQIV drivers.
For crypto_inc(), this simply involves making the 4-byte stride
conditional on HAVE_EFFICIENT_UNALIGNED_ACCESS being set, given that
it typically operates on 16 byte buffers.
For crypto_xor(), an algorithm is implemented that simply runs through
the input using the largest strides possible if unaligned accesses are
allowed. If they are not, an optimal sequence of memory accesses is
emitted that takes the relative alignment of the input buffers into
account, e.g., if the relative misalignment of dst and src is 4 bytes,
the entire xor operation will be completed using 4 byte loads and stores
(modulo unaligned bits at the start and end). Note that all expressions
involving misalign are simply eliminated by the compiler when
HAVE_EFFICIENT_UNALIGNED_ACCESS is defined.
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2017-02-05 03:06:12 -07:00
|
|
|
alignmask = alg->cra_alignmask;
|
2013-04-08 01:48:44 -06:00
|
|
|
inst->alg.base.cra_alignmask = alignmask;
|
|
|
|
inst->alg.base.cra_priority = alg->cra_priority;
|
|
|
|
inst->alg.base.cra_blocksize = alg->cra_blocksize;
|
|
|
|
|
|
|
|
inst->alg.digestsize = alg->cra_blocksize;
|
|
|
|
inst->alg.descsize =
|
|
|
|
ALIGN(sizeof(struct cmac_desc_ctx), crypto_tfm_ctx_alignment())
|
|
|
|
+ (alignmask & ~(crypto_tfm_ctx_alignment() - 1))
|
|
|
|
+ alg->cra_blocksize * 2;
|
|
|
|
|
|
|
|
inst->alg.base.cra_ctxsize =
|
2016-10-10 11:15:15 -06:00
|
|
|
ALIGN(sizeof(struct cmac_tfm_ctx), crypto_tfm_ctx_alignment())
|
|
|
|
+ ((alignmask | (__alignof__(__be64) - 1)) &
|
|
|
|
~(crypto_tfm_ctx_alignment() - 1))
|
2013-04-08 01:48:44 -06:00
|
|
|
+ alg->cra_blocksize * 2;
|
|
|
|
|
|
|
|
inst->alg.base.cra_init = cmac_init_tfm;
|
|
|
|
inst->alg.base.cra_exit = cmac_exit_tfm;
|
|
|
|
|
|
|
|
inst->alg.init = crypto_cmac_digest_init;
|
|
|
|
inst->alg.update = crypto_cmac_digest_update;
|
|
|
|
inst->alg.final = crypto_cmac_digest_final;
|
|
|
|
inst->alg.setkey = crypto_cmac_digest_setkey;
|
|
|
|
|
2020-01-02 21:04:38 -07:00
|
|
|
inst->free = shash_free_singlespawn_instance;
|
|
|
|
|
2013-04-08 01:48:44 -06:00
|
|
|
err = shash_register_instance(tmpl, inst);
|
|
|
|
if (err) {
|
2020-01-02 20:59:02 -07:00
|
|
|
err_free_inst:
|
2020-01-02 21:04:38 -07:00
|
|
|
shash_free_singlespawn_instance(inst);
|
2013-04-08 01:48:44 -06:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct crypto_template crypto_cmac_tmpl = {
|
|
|
|
.name = "cmac",
|
|
|
|
.create = cmac_create,
|
|
|
|
.module = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init crypto_cmac_module_init(void)
|
|
|
|
{
|
|
|
|
return crypto_register_template(&crypto_cmac_tmpl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit crypto_cmac_module_exit(void)
|
|
|
|
{
|
|
|
|
crypto_unregister_template(&crypto_cmac_tmpl);
|
|
|
|
}
|
|
|
|
|
2019-04-11 22:57:42 -06:00
|
|
|
subsys_initcall(crypto_cmac_module_init);
|
2013-04-08 01:48:44 -06:00
|
|
|
module_exit(crypto_cmac_module_exit);
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("CMAC keyed hash algorithm");
|
2014-11-24 17:32:38 -07:00
|
|
|
MODULE_ALIAS_CRYPTO("cmac");
|