Gh0st
/
linux
mirror of https://github.com/torvalds/linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

crypto: hctr2 - Convert to use POLYVAL library 

The "hash function" in hctr2 is fixed at POLYVAL; it can never vary.
Just use the POLYVAL library, which is much easier to use than the
crypto_shash API.  It's faster, uses fixed-size structs, and never fails
(all the functions return void).

Note that this eliminates the only known user of the polyval support in
crypto_shash.  A later commit will remove support for polyval from
crypto_shash, given that the library API is sufficient.

Reviewed-by: Ard Biesheuvel <ardb@kernel.org>
Link: https://lore.kernel.org/r/20251109234726.638437-7-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@kernel.org>
This commit is contained in:
Eric Biggers 2025-11-09 15:47:21 -08:00
parent 4d8da35579
commit d35abc0b1d
3 changed files with 64 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crypto/Kconfig
View File

@ -696,7 +696,7 @@ config CRYPTO_ECB
config CRYPTO_HCTR2 config CRYPTO_HCTR2
tristate "HCTR2" tristate "HCTR2"
select CRYPTO_XCTR select CRYPTO_XCTR
select CRYPTO_POLYVAL select CRYPTO_LIB_POLYVAL
select CRYPTO_MANAGER select CRYPTO_MANAGER
help help
HCTR2 length-preserving encryption mode HCTR2 length-preserving encryption mode

222
crypto/hctr2.c
View File

@ -17,7 +17,6 @@
*/ */
#include <crypto/internal/cipher.h> #include <crypto/internal/cipher.h>
#include <crypto/internal/hash.h>
#include <crypto/internal/skcipher.h> #include <crypto/internal/skcipher.h>
#include <crypto/polyval.h> #include <crypto/polyval.h>
#include <crypto/scatterwalk.h> #include <crypto/scatterwalk.h>
@ -37,23 +36,14 @@
struct hctr2_instance_ctx { struct hctr2_instance_ctx {
struct crypto_cipher_spawn blockcipher_spawn; struct crypto_cipher_spawn blockcipher_spawn;
struct crypto_skcipher_spawn xctr_spawn; struct crypto_skcipher_spawn xctr_spawn;
struct crypto_shash_spawn polyval_spawn;
}; };
struct hctr2_tfm_ctx { struct hctr2_tfm_ctx {
struct crypto_cipher *blockcipher; struct crypto_cipher *blockcipher;
struct crypto_skcipher *xctr; struct crypto_skcipher *xctr;
struct crypto_shash *polyval; struct polyval_key poly_key;
struct polyval_elem hashed_tweaklens[2];
u8 L[BLOCKCIPHER_BLOCK_SIZE]; u8 L[BLOCKCIPHER_BLOCK_SIZE];
int hashed_tweak_offset;
/*
* This struct is allocated with extra space for two exported hash
* states. Since the hash state size is not known at compile-time, we
* can't add these to the struct directly.
*
* hashed_tweaklen_divisible;
* hashed_tweaklen_remainder;
*/
}; };
struct hctr2_request_ctx { struct hctr2_request_ctx {
@ -63,39 +53,17 @@ struct hctr2_request_ctx {
struct scatterlist *bulk_part_src; struct scatterlist *bulk_part_src;
struct scatterlist sg_src[2]; struct scatterlist sg_src[2];
struct scatterlist sg_dst[2]; struct scatterlist sg_dst[2];
struct polyval_elem hashed_tweak;
/* /*
* Sub-request sizes are unknown at compile-time, so they need to go * skcipher sub-request size is unknown at compile-time, so it needs to
* after the members with known sizes. * go after the members with known sizes.
*/ */
union { union {
struct shash_desc hash_desc; struct polyval_ctx poly_ctx;
struct skcipher_request xctr_req; struct skcipher_request xctr_req;
} u; } u;
/*
* This struct is allocated with extra space for one exported hash
* state. Since the hash state size is not known at compile-time, we
* can't add it to the struct directly.
*
* hashed_tweak;
*/
}; };
static inline u8 *hctr2_hashed_tweaklen(const struct hctr2_tfm_ctx *tctx,
bool has_remainder)
{
u8 *p = (u8 *)tctx + sizeof(*tctx);
if (has_remainder) /* For messages not a multiple of block length */
p += crypto_shash_statesize(tctx->polyval);
return p;
}
static inline u8 *hctr2_hashed_tweak(const struct hctr2_tfm_ctx *tctx,
struct hctr2_request_ctx *rctx)
{
return (u8 *)rctx + tctx->hashed_tweak_offset;
}
/* /*
* The input data for each HCTR2 hash step begins with a 16-byte block that * The input data for each HCTR2 hash step begins with a 16-byte block that
* contains the tweak length and a flag that indicates whether the input is evenly * contains the tweak length and a flag that indicates whether the input is evenly
@ -106,24 +74,23 @@ static inline u8 *hctr2_hashed_tweak(const struct hctr2_tfm_ctx *tctx,
* *
* These precomputed hashes are stored in hctr2_tfm_ctx. * These precomputed hashes are stored in hctr2_tfm_ctx.
*/ */
static int hctr2_hash_tweaklen(struct hctr2_tfm_ctx *tctx, bool has_remainder) static void hctr2_hash_tweaklens(struct hctr2_tfm_ctx *tctx)
{ {
SHASH_DESC_ON_STACK(shash, tfm->polyval); struct polyval_ctx ctx;
__le64 tweak_length_block[2];
int err;
shash->tfm = tctx->polyval; for (int has_remainder = 0; has_remainder < 2; has_remainder++) {
memset(tweak_length_block, 0, sizeof(tweak_length_block)); const __le64 tweak_length_block[2] = {
cpu_to_le64(TWEAK_SIZE * 8 * 2 + 2 + has_remainder),
};
tweak_length_block[0] = cpu_to_le64(TWEAK_SIZE * 8 * 2 + 2 + has_remainder); polyval_init(&ctx, &tctx->poly_key);
err = crypto_shash_init(shash); polyval_update(&ctx, (const u8 *)&tweak_length_block,
if (err) sizeof(tweak_length_block));
return err; static_assert(sizeof(tweak_length_block) == POLYVAL_BLOCK_SIZE);
err = crypto_shash_update(shash, (u8 *)tweak_length_block, polyval_export_blkaligned(
POLYVAL_BLOCK_SIZE); &ctx, &tctx->hashed_tweaklens[has_remainder]);
if (err) }
return err; memzero_explicit(&ctx, sizeof(ctx));
return crypto_shash_export(shash, hctr2_hashed_tweaklen(tctx, has_remainder));
} }
static int hctr2_setkey(struct crypto_skcipher *tfm, const u8 *key, static int hctr2_setkey(struct crypto_skcipher *tfm, const u8 *key,
@ -156,51 +123,42 @@ static int hctr2_setkey(struct crypto_skcipher *tfm, const u8 *key,
tctx->L[0] = 0x01; tctx->L[0] = 0x01;
crypto_cipher_encrypt_one(tctx->blockcipher, tctx->L, tctx->L); crypto_cipher_encrypt_one(tctx->blockcipher, tctx->L, tctx->L);
crypto_shash_clear_flags(tctx->polyval, CRYPTO_TFM_REQ_MASK); static_assert(sizeof(hbar) == POLYVAL_BLOCK_SIZE);
crypto_shash_set_flags(tctx->polyval, crypto_skcipher_get_flags(tfm) & polyval_preparekey(&tctx->poly_key, hbar);
CRYPTO_TFM_REQ_MASK);
err = crypto_shash_setkey(tctx->polyval, hbar, BLOCKCIPHER_BLOCK_SIZE);
if (err)
return err;
memzero_explicit(hbar, sizeof(hbar)); memzero_explicit(hbar, sizeof(hbar));
return hctr2_hash_tweaklen(tctx, true) ?: hctr2_hash_tweaklen(tctx, false); hctr2_hash_tweaklens(tctx);
return 0;
} }
static int hctr2_hash_tweak(struct skcipher_request *req) static void hctr2_hash_tweak(struct skcipher_request *req)
{ {
struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
const struct hctr2_tfm_ctx *tctx = crypto_skcipher_ctx(tfm); const struct hctr2_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
struct hctr2_request_ctx *rctx = skcipher_request_ctx(req); struct hctr2_request_ctx *rctx = skcipher_request_ctx(req);
struct shash_desc *hash_desc = &rctx->u.hash_desc; struct polyval_ctx *poly_ctx = &rctx->u.poly_ctx;
int err;
bool has_remainder = req->cryptlen % POLYVAL_BLOCK_SIZE; bool has_remainder = req->cryptlen % POLYVAL_BLOCK_SIZE;
hash_desc->tfm = tctx->polyval; polyval_import_blkaligned(poly_ctx, &tctx->poly_key,
err = crypto_shash_import(hash_desc, hctr2_hashed_tweaklen(tctx, has_remainder)); &tctx->hashed_tweaklens[has_remainder]);
if (err) polyval_update(poly_ctx, req->iv, TWEAK_SIZE);
return err;
err = crypto_shash_update(hash_desc, req->iv, TWEAK_SIZE);
if (err)
return err;
// Store the hashed tweak, since we need it when computing both // Store the hashed tweak, since we need it when computing both
// H(T || N) and H(T || V). // H(T || N) and H(T || V).
return crypto_shash_export(hash_desc, hctr2_hashed_tweak(tctx, rctx)); static_assert(TWEAK_SIZE % POLYVAL_BLOCK_SIZE == 0);
polyval_export_blkaligned(poly_ctx, &rctx->hashed_tweak);
} }
static int hctr2_hash_message(struct skcipher_request *req, static void hctr2_hash_message(struct skcipher_request *req,
struct scatterlist *sgl, struct scatterlist *sgl,
u8 digest[POLYVAL_DIGEST_SIZE]) u8 digest[POLYVAL_DIGEST_SIZE])
{ {
static const u8 padding[BLOCKCIPHER_BLOCK_SIZE] = { 0x1 }; static const u8 padding = 0x1;
struct hctr2_request_ctx *rctx = skcipher_request_ctx(req); struct hctr2_request_ctx *rctx = skcipher_request_ctx(req);
struct shash_desc *hash_desc = &rctx->u.hash_desc; struct polyval_ctx *poly_ctx = &rctx->u.poly_ctx;
const unsigned int bulk_len = req->cryptlen - BLOCKCIPHER_BLOCK_SIZE; const unsigned int bulk_len = req->cryptlen - BLOCKCIPHER_BLOCK_SIZE;
struct sg_mapping_iter miter; struct sg_mapping_iter miter;
unsigned int remainder = bulk_len % BLOCKCIPHER_BLOCK_SIZE;
int i; int i;
int err = 0;
int n = 0; int n = 0;
sg_miter_start(&miter, sgl, sg_nents(sgl), sg_miter_start(&miter, sgl, sg_nents(sgl),
@ -208,22 +166,13 @@ static int hctr2_hash_message(struct skcipher_request *req,
for (i = 0; i < bulk_len; i += n) { for (i = 0; i < bulk_len; i += n) {
sg_miter_next(&miter); sg_miter_next(&miter);
n = min_t(unsigned int, miter.length, bulk_len - i); n = min_t(unsigned int, miter.length, bulk_len - i);
err = crypto_shash_update(hash_desc, miter.addr, n); polyval_update(poly_ctx, miter.addr, n);
if (err)
break;
} }
sg_miter_stop(&miter); sg_miter_stop(&miter);
if (err) if (req->cryptlen % BLOCKCIPHER_BLOCK_SIZE)
return err; polyval_update(poly_ctx, &padding, 1);
polyval_final(poly_ctx, digest);
if (remainder) {
err = crypto_shash_update(hash_desc, padding,
BLOCKCIPHER_BLOCK_SIZE - remainder);
if (err)
return err;
}
return crypto_shash_final(hash_desc, digest);
} }
static int hctr2_finish(struct skcipher_request *req) static int hctr2_finish(struct skcipher_request *req)
@ -231,19 +180,14 @@ static int hctr2_finish(struct skcipher_request *req)
struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
const struct hctr2_tfm_ctx *tctx = crypto_skcipher_ctx(tfm); const struct hctr2_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
struct hctr2_request_ctx *rctx = skcipher_request_ctx(req); struct hctr2_request_ctx *rctx = skcipher_request_ctx(req);
struct polyval_ctx *poly_ctx = &rctx->u.poly_ctx;
u8 digest[POLYVAL_DIGEST_SIZE]; u8 digest[POLYVAL_DIGEST_SIZE];
struct shash_desc *hash_desc = &rctx->u.hash_desc;
int err;
// U = UU ^ H(T || V) // U = UU ^ H(T || V)
// or M = MM ^ H(T || N) // or M = MM ^ H(T || N)
hash_desc->tfm = tctx->polyval; polyval_import_blkaligned(poly_ctx, &tctx->poly_key,
err = crypto_shash_import(hash_desc, hctr2_hashed_tweak(tctx, rctx)); &rctx->hashed_tweak);
if (err) hctr2_hash_message(req, rctx->bulk_part_dst, digest);
return err;
err = hctr2_hash_message(req, rctx->bulk_part_dst, digest);
if (err)
return err;
crypto_xor(rctx->first_block, digest, BLOCKCIPHER_BLOCK_SIZE); crypto_xor(rctx->first_block, digest, BLOCKCIPHER_BLOCK_SIZE);
// Copy U (or M) into dst scatterlist // Copy U (or M) into dst scatterlist
@ -269,7 +213,6 @@ static int hctr2_crypt(struct skcipher_request *req, bool enc)
struct hctr2_request_ctx *rctx = skcipher_request_ctx(req); struct hctr2_request_ctx *rctx = skcipher_request_ctx(req);
u8 digest[POLYVAL_DIGEST_SIZE]; u8 digest[POLYVAL_DIGEST_SIZE];
int bulk_len = req->cryptlen - BLOCKCIPHER_BLOCK_SIZE; int bulk_len = req->cryptlen - BLOCKCIPHER_BLOCK_SIZE;
int err;
// Requests must be at least one block // Requests must be at least one block
if (req->cryptlen < BLOCKCIPHER_BLOCK_SIZE) if (req->cryptlen < BLOCKCIPHER_BLOCK_SIZE)
@ -287,12 +230,8 @@ static int hctr2_crypt(struct skcipher_request *req, bool enc)
// MM = M ^ H(T || N) // MM = M ^ H(T || N)
// or UU = U ^ H(T || V) // or UU = U ^ H(T || V)
err = hctr2_hash_tweak(req); hctr2_hash_tweak(req);
if (err) hctr2_hash_message(req, rctx->bulk_part_src, digest);
return err;
err = hctr2_hash_message(req, rctx->bulk_part_src, digest);
if (err)
return err;
crypto_xor(digest, rctx->first_block, BLOCKCIPHER_BLOCK_SIZE); crypto_xor(digest, rctx->first_block, BLOCKCIPHER_BLOCK_SIZE);
// UU = E(MM) // UU = E(MM)
@ -338,8 +277,6 @@ static int hctr2_init_tfm(struct crypto_skcipher *tfm)
struct hctr2_tfm_ctx *tctx = crypto_skcipher_ctx(tfm); struct hctr2_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
struct crypto_skcipher *xctr; struct crypto_skcipher *xctr;
struct crypto_cipher *blockcipher; struct crypto_cipher *blockcipher;
struct crypto_shash *polyval;
unsigned int subreq_size;
int err; int err;
xctr = crypto_spawn_skcipher(&ictx->xctr_spawn); xctr = crypto_spawn_skcipher(&ictx->xctr_spawn);
@ -352,31 +289,17 @@ static int hctr2_init_tfm(struct crypto_skcipher *tfm)
goto err_free_xctr; goto err_free_xctr;
} }
polyval = crypto_spawn_shash(&ictx->polyval_spawn);
if (IS_ERR(polyval)) {
err = PTR_ERR(polyval);
goto err_free_blockcipher;
}
tctx->xctr = xctr; tctx->xctr = xctr;
tctx->blockcipher = blockcipher; tctx->blockcipher = blockcipher;
tctx->polyval = polyval;
BUILD_BUG_ON(offsetofend(struct hctr2_request_ctx, u) != BUILD_BUG_ON(offsetofend(struct hctr2_request_ctx, u) !=
sizeof(struct hctr2_request_ctx)); sizeof(struct hctr2_request_ctx));
subreq_size = max(sizeof_field(struct hctr2_request_ctx, u.hash_desc) + crypto_skcipher_set_reqsize(
crypto_shash_descsize(polyval), tfm, max(sizeof(struct hctr2_request_ctx),
sizeof_field(struct hctr2_request_ctx, u.xctr_req) + offsetofend(struct hctr2_request_ctx, u.xctr_req) +
crypto_skcipher_reqsize(xctr)); crypto_skcipher_reqsize(xctr)));
tctx->hashed_tweak_offset = offsetof(struct hctr2_request_ctx, u) +
subreq_size;
crypto_skcipher_set_reqsize(tfm, tctx->hashed_tweak_offset +
crypto_shash_statesize(polyval));
return 0; return 0;
err_free_blockcipher:
crypto_free_cipher(blockcipher);
err_free_xctr: err_free_xctr:
crypto_free_skcipher(xctr); crypto_free_skcipher(xctr);
return err; return err;
@ -388,7 +311,6 @@ static void hctr2_exit_tfm(struct crypto_skcipher *tfm)
crypto_free_cipher(tctx->blockcipher); crypto_free_cipher(tctx->blockcipher);
crypto_free_skcipher(tctx->xctr); crypto_free_skcipher(tctx->xctr);
crypto_free_shash(tctx->polyval);
} }
static void hctr2_free_instance(struct skcipher_instance *inst) static void hctr2_free_instance(struct skcipher_instance *inst)
@ -397,21 +319,17 @@ static void hctr2_free_instance(struct skcipher_instance *inst)
crypto_drop_cipher(&ictx->blockcipher_spawn); crypto_drop_cipher(&ictx->blockcipher_spawn);
crypto_drop_skcipher(&ictx->xctr_spawn); crypto_drop_skcipher(&ictx->xctr_spawn);
crypto_drop_shash(&ictx->polyval_spawn);
kfree(inst); kfree(inst);
} }
static int hctr2_create_common(struct crypto_template *tmpl, static int hctr2_create_common(struct crypto_template *tmpl, struct rtattr **tb,
struct rtattr **tb, const char *xctr_name)
const char *xctr_name,
const char *polyval_name)
{ {
struct skcipher_alg_common *xctr_alg; struct skcipher_alg_common *xctr_alg;
u32 mask; u32 mask;
struct skcipher_instance *inst; struct skcipher_instance *inst;
struct hctr2_instance_ctx *ictx; struct hctr2_instance_ctx *ictx;
struct crypto_alg *blockcipher_alg; struct crypto_alg *blockcipher_alg;
struct shash_alg *polyval_alg;
char blockcipher_name[CRYPTO_MAX_ALG_NAME]; char blockcipher_name[CRYPTO_MAX_ALG_NAME];
int len; int len;
int err; int err;
@ -457,19 +375,6 @@ static int hctr2_create_common(struct crypto_template *tmpl,
if (blockcipher_alg->cra_blocksize != BLOCKCIPHER_BLOCK_SIZE) if (blockcipher_alg->cra_blocksize != BLOCKCIPHER_BLOCK_SIZE)
goto err_free_inst; goto err_free_inst;
/* Polyval ε-∆U hash function */
err = crypto_grab_shash(&ictx->polyval_spawn,
skcipher_crypto_instance(inst),
polyval_name, 0, mask);
if (err)
goto err_free_inst;
polyval_alg = crypto_spawn_shash_alg(&ictx->polyval_spawn);
/* Ensure Polyval is being used */
err = -EINVAL;
if (strcmp(polyval_alg->base.cra_name, "polyval") != 0)
goto err_free_inst;
/* Instance fields */ /* Instance fields */
err = -ENAMETOOLONG; err = -ENAMETOOLONG;
@ -477,22 +382,16 @@ static int hctr2_create_common(struct crypto_template *tmpl,
blockcipher_alg->cra_name) >= CRYPTO_MAX_ALG_NAME) blockcipher_alg->cra_name) >= CRYPTO_MAX_ALG_NAME)
goto err_free_inst; goto err_free_inst;
if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME, if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
"hctr2_base(%s,%s)", "hctr2_base(%s,polyval-lib)",
xctr_alg->base.cra_driver_name, xctr_alg->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
polyval_alg->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
goto err_free_inst; goto err_free_inst;
inst->alg.base.cra_blocksize = BLOCKCIPHER_BLOCK_SIZE; inst->alg.base.cra_blocksize = BLOCKCIPHER_BLOCK_SIZE;
inst->alg.base.cra_ctxsize = sizeof(struct hctr2_tfm_ctx) + inst->alg.base.cra_ctxsize = sizeof(struct hctr2_tfm_ctx);
polyval_alg->statesize * 2;
inst->alg.base.cra_alignmask = xctr_alg->base.cra_alignmask; inst->alg.base.cra_alignmask = xctr_alg->base.cra_alignmask;
/*
* The hash function is called twice, so it is weighted higher than the
* xctr and blockcipher.
*/
inst->alg.base.cra_priority = (2 * xctr_alg->base.cra_priority + inst->alg.base.cra_priority = (2 * xctr_alg->base.cra_priority +
4 * polyval_alg->base.cra_priority + blockcipher_alg->cra_priority) /
blockcipher_alg->cra_priority) / 7; 3;
inst->alg.setkey = hctr2_setkey; inst->alg.setkey = hctr2_setkey;
inst->alg.encrypt = hctr2_encrypt; inst->alg.encrypt = hctr2_encrypt;
@ -525,8 +424,11 @@ static int hctr2_create_base(struct crypto_template *tmpl, struct rtattr **tb)
polyval_name = crypto_attr_alg_name(tb[2]); polyval_name = crypto_attr_alg_name(tb[2]);
if (IS_ERR(polyval_name)) if (IS_ERR(polyval_name))
return PTR_ERR(polyval_name); return PTR_ERR(polyval_name);
if (strcmp(polyval_name, "polyval") != 0 &&
strcmp(polyval_name, "polyval-lib") != 0)
return -ENOENT;
return hctr2_create_common(tmpl, tb, xctr_name, polyval_name); return hctr2_create_common(tmpl, tb, xctr_name);
} }
static int hctr2_create(struct crypto_template *tmpl, struct rtattr **tb) static int hctr2_create(struct crypto_template *tmpl, struct rtattr **tb)
@ -542,7 +444,7 @@ static int hctr2_create(struct crypto_template *tmpl, struct rtattr **tb)
blockcipher_name) >= CRYPTO_MAX_ALG_NAME) blockcipher_name) >= CRYPTO_MAX_ALG_NAME)
return -ENAMETOOLONG; return -ENAMETOOLONG;
return hctr2_create_common(tmpl, tb, xctr_name, "polyval"); return hctr2_create_common(tmpl, tb, xctr_name);
} }
static struct crypto_template hctr2_tmpls[] = { static struct crypto_template hctr2_tmpls[] = {

3
crypto/testmgr.c
View File

@ -5059,8 +5059,7 @@ static const struct alg_test_desc alg_test_descs[] = {
} }
}, { }, {
.alg = "hctr2(aes)", .alg = "hctr2(aes)",
.generic_driver = .generic_driver = "hctr2_base(xctr(aes-generic),polyval-lib)",
"hctr2_base(xctr(aes-generic),polyval-generic)",
.test = alg_test_skcipher, .test = alg_test_skcipher,
.suite = { .suite = {
.cipher = __VECS(aes_hctr2_tv_template) .cipher = __VECS(aes_hctr2_tv_template)