leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

crypto: skcipher - remove crypto_skcipher::keysize

Browse Source 
Due to the removal of the blkcipher and ablkcipher algorithm types,
crypto_skcipher::keysize is now redundant since it always equals
crypto_skcipher_alg(tfm)->max_keysize.

Remove it and update crypto_skcipher_default_keysize() accordingly.

Also rename crypto_skcipher_default_keysize() to
crypto_skcipher_max_keysize() to clarify that it specifically returns
the maximum key size, not some unspecified "default".

Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Eric Biggers 2019-11-29 10:23:04 -08:00 committed by Herbert Xu
parent 140734d371
commit 9ac0d13693
5 changed files with 12 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
crypto/skcipher.c
View File

@ -585,7 +585,7 @@ static unsigned int crypto_skcipher_extsize(struct crypto_alg *alg)
static void skcipher_set_needkey(struct crypto_skcipher *tfm) static void skcipher_set_needkey(struct crypto_skcipher *tfm)
{ {
if (tfm->keysize) if (crypto_skcipher_max_keysize(tfm) != 0)
crypto_skcipher_set_flags(tfm, CRYPTO_TFM_NEED_KEY); crypto_skcipher_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
} }
@ -686,7 +686,6 @@ static int crypto_skcipher_init_tfm(struct crypto_tfm *tfm)
skcipher->setkey = skcipher_setkey; skcipher->setkey = skcipher_setkey;
skcipher->encrypt = alg->encrypt; skcipher->encrypt = alg->encrypt;
skcipher->decrypt = alg->decrypt; skcipher->decrypt = alg->decrypt;
skcipher->keysize = alg->max_keysize;
skcipher_set_needkey(skcipher); skcipher_set_needkey(skcipher);

10
crypto/testmgr.c
View File

@ -2647,7 +2647,7 @@ static void generate_random_cipher_testvec(struct skcipher_request *req,
char *name, size_t max_namelen) char *name, size_t max_namelen)
{ {
struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
const unsigned int maxkeysize = tfm->keysize; const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm);
const unsigned int ivsize = crypto_skcipher_ivsize(tfm); const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
struct scatterlist src, dst; struct scatterlist src, dst;
u8 iv[MAX_IVLEN]; u8 iv[MAX_IVLEN];
@ -2693,6 +2693,7 @@ static int test_skcipher_vs_generic_impl(const char *driver,
struct cipher_test_sglists *tsgls) struct cipher_test_sglists *tsgls)
{ {
struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm);
const unsigned int ivsize = crypto_skcipher_ivsize(tfm); const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
const unsigned int blocksize = crypto_skcipher_blocksize(tfm); const unsigned int blocksize = crypto_skcipher_blocksize(tfm);
const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN; const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN;
@ -2751,9 +2752,10 @@ static int test_skcipher_vs_generic_impl(const char *driver,
/* Check the algorithm properties for consistency. */ /* Check the algorithm properties for consistency. */
if (tfm->keysize != generic_tfm->keysize) { if (maxkeysize != crypto_skcipher_max_keysize(generic_tfm)) {
pr_err("alg: skcipher: max keysize for %s (%u) doesn't match generic impl (%u)\n", pr_err("alg: skcipher: max keysize for %s (%u) doesn't match generic impl (%u)\n",
driver, tfm->keysize, generic_tfm->keysize); driver, maxkeysize,
crypto_skcipher_max_keysize(generic_tfm));
err = -EINVAL; err = -EINVAL;
goto out; goto out;
} }
@ -2778,7 +2780,7 @@ static int test_skcipher_vs_generic_impl(const char *driver,
* the other implementation against them. * the other implementation against them.
*/ */
vec.key = kmalloc(tfm->keysize, GFP_KERNEL); vec.key = kmalloc(maxkeysize, GFP_KERNEL);
vec.iv = kmalloc(ivsize, GFP_KERNEL); vec.iv = kmalloc(ivsize, GFP_KERNEL);
vec.ptext = kmalloc(maxdatasize, GFP_KERNEL); vec.ptext = kmalloc(maxdatasize, GFP_KERNEL);
vec.ctext = kmalloc(maxdatasize, GFP_KERNEL); vec.ctext = kmalloc(maxdatasize, GFP_KERNEL);

2
fs/ecryptfs/crypto.c
View File

@ -1586,7 +1586,7 @@ ecryptfs_process_key_cipher(struct crypto_skcipher **key_tfm,
} }
crypto_skcipher_set_flags(*key_tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS); crypto_skcipher_set_flags(*key_tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
if (*key_size == 0) if (*key_size == 0)
*key_size = crypto_skcipher_default_keysize(*key_tfm); *key_size = crypto_skcipher_max_keysize(*key_tfm);
get_random_bytes(dummy_key, *key_size); get_random_bytes(dummy_key, *key_size);
rc = crypto_skcipher_setkey(*key_tfm, dummy_key, *key_size); rc = crypto_skcipher_setkey(*key_tfm, dummy_key, *key_size);
if (rc) { if (rc) {

4
fs/ecryptfs/keystore.c
View File

@ -2204,9 +2204,9 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
if (mount_crypt_stat->global_default_cipher_key_size == 0) { if (mount_crypt_stat->global_default_cipher_key_size == 0) {
printk(KERN_WARNING "No key size specified at mount; " printk(KERN_WARNING "No key size specified at mount; "
"defaulting to [%d]\n", "defaulting to [%d]\n",
crypto_skcipher_default_keysize(tfm)); crypto_skcipher_max_keysize(tfm));
mount_crypt_stat->global_default_cipher_key_size = mount_crypt_stat->global_default_cipher_key_size =
crypto_skcipher_default_keysize(tfm); crypto_skcipher_max_keysize(tfm);
} }
if (crypt_stat->key_size == 0) if (crypt_stat->key_size == 0)
crypt_stat->key_size = crypt_stat->key_size =

5
include/crypto/skcipher.h
View File

@ -41,7 +41,6 @@ struct crypto_skcipher {
int (*decrypt)(struct skcipher_request *req); int (*decrypt)(struct skcipher_request *req);
unsigned int reqsize; unsigned int reqsize;
unsigned int keysize;
struct crypto_tfm base; struct crypto_tfm base;
}; };
@ -377,10 +376,10 @@ static inline int crypto_sync_skcipher_setkey(struct crypto_sync_skcipher *tfm,
return crypto_skcipher_setkey(&tfm->base, key, keylen); return crypto_skcipher_setkey(&tfm->base, key, keylen);
} }
static inline unsigned int crypto_skcipher_default_keysize( static inline unsigned int crypto_skcipher_max_keysize(
struct crypto_skcipher *tfm) struct crypto_skcipher *tfm)
{ {
return tfm->keysize; return crypto_skcipher_alg(tfm)->max_keysize;
} }
/** /**