crypto: caam - xts(aes) updates
v2 cover crypto: caam - xts(aes) updates
From: Andrei Botila <[email protected]>
This patch series fixes some problems in CAAM's implementation of xts(aes):
- CAAM until Era 9 can't process XTS with 16B IV
- CAAM can only process in hardware XTS key lengths of 16B and 32B
- These hardware limitations are resolved through a fallback
- CAAM used to return 0 for XTS block length equal to zero
This patch series also adds a new feature in CAAM's xts(aes):
- CAAM is now able to process XTS with 16B IV in HW
Changes since v1:
- use only get_unaligned() for calculating XTS IV size
- fixed the double calling of crypto_skcipher_set_reqsize() in case of XTS
- added a patch which modifies the return value for XTS when block length is equal to zero
Andrei Botila (12):
crypto: caam/jr - add fallback for XTS with more than 8B IV
crypto: caam/qi - add fallback for XTS with more than 8B IV
crypto: caam/qi2 - add fallback for XTS with more than 8B IV
crypto: caam/jr - add support for more XTS key lengths
crypto: caam/qi - add support for more XTS key lengths
crypto: caam/qi2 - add support for more XTS key lengths
crypto: caam/jr - add xts check for block length equal to zero
crypto: caam/qi - add xts check for block length equal to zero
crypto: caam/qi2 - add xts check for block length equal to zero
crypto: caam/jr - add support for XTS with 16B IV
crypto: caam/qi - add support for XTS with 16B IV
crypto: caam/qi2 - add support for XTS with 16B IV
drivers/crypto/caam/Kconfig | 3 + drivers/crypto/caam/caamalg.c | 92 +++++++++++++++++++++--- drivers/crypto/caam/caamalg_desc.c | 27 ++++--- drivers/crypto/caam/caamalg_qi.c | 92 +++++++++++++++++++++--- drivers/crypto/caam/caamalg_qi2.c | 109 ++++++++++++++++++++++++++--- drivers/crypto/caam/caamalg_qi2.h | 2 + 6 files changed, 287 insertions(+), 38 deletions(-)
Signature · 1 line
2.17.1
PATCH v2 1/12 crypto: caam/jr - add fallback for XTS with more than 8B IV
From: Andrei Botila <[email protected]>
A hardware limitation exists for CAAM until Era 9 which restricts the accelerator to IVs with only 8 bytes. When CAAM has a lower era a fallback is necessary to process 16 bytes IV.
--- drivers/crypto/caam/Kconfig | 1 + drivers/crypto/caam/caamalg.c | 70 +++++++++++++++++++++++++++++++---- 2 files changed, 64 insertions(+), 7 deletions(-)
drivers/crypto/caam/Kconfig +1 -0
@@ -101,6 +101,7 @@ config CRYPTO_DEV_FSL_CAAM_CRYPTO_API select CRYPTO_AUTHENC select CRYPTO_SKCIPHER select CRYPTO_LIB_DES + select CRYPTO_XTS help Selecting this will offload crypto for users of the scatterlist crypto API (such as the linux native IPSec
drivers/crypto/caam/caamalg.c +63 -7
137 lines not on this page · raw message
Signature · 1 line
2.17.1
Horia Geantă
maintainerRe: [PATCH v2 01/12] crypto: caam/jr - add fallback for XTS with more than 8B IV
drivers/crypto/caam/caamalg.c static int skcipher_do_one_req(struct crypto_engine *engine, void *areq) · line 1774
Quoted 9 lines · Andrei Botila (OSS)
drivers/crypto/caam/caamalg.c +9
-0+static bool xts_skcipher_ivsize (struct skcipher_request *req) +{ +struct crypto_skcipher *skcipher =crypto_skcipher_reqtfm (req); +unsigned int ivsize =crypto_skcipher_ivsize (skcipher); +u64 size =0 ; + + size =get_unaligned ((u64 *)(req->iv + (ivsize /2 ))); + +return !!size;
Just get rid of the "size" local variable and return !!get_unaligned(...). Also the function should be inline.
Quoted 22 lines
drivers/crypto/caam/caamalg.c +11
-4@@ -3344,13 +3379,30 @@ static int caam_cra_init(struct crypto_skcipher *tfm)struct caam_skcipher_alg *caam_alg =container_of (alg,typeof (*caam_alg), skcipher);struct caam_ctx *ctx =crypto_skcipher_ctx (tfm); - -crypto_skcipher_set_reqsize (tfm,sizeof (struct caam_skcipher_req_ctx )); +u32 alg_aai = caam_alg->caam.class1_alg_type &OP_ALG_AAI_MASK ; ctx->enginectx.op.do_one_request = skcipher_do_one_req; -return caam_init_common (crypto_skcipher_ctx (tfm), &caam_alg->caam, - false); +if (alg_aai ==OP_ALG_AAI_XTS ) { +const char *tfm_name =crypto_tfm_alg_name (&tfm->base); +struct crypto_skcipher *fallback; + + fallback =crypto_alloc_skcipher (tfm_name,0 , +CRYPTO_ALG_NEED_FALLBACK ); +if (IS_ERR (fallback)) { +dev_err (ctx->jrdev,"Failed to allocate %s fallback: %ld\n" , + tfm_name,PTR_ERR (fallback)); +return PTR_ERR (fallback);
drivers/crypto/caam/caamalg.c static int caam_cra_init(struct crypto_skcipher *tfm) · line 3405
Quoted 10 lines
drivers/crypto/caam/caamalg.c +10
-0+ } + + ctx->fallback = fallback; +crypto_skcipher_set_reqsize (tfm,sizeof (struct caam_skcipher_req_ctx ) + +crypto_skcipher_reqsize (fallback)); + }else { +crypto_skcipher_set_reqsize (tfm,sizeof (struct caam_skcipher_req_ctx )); + } + +return caam_init_common (ctx, &caam_alg->caam, false);
In case caam_init_common() fails, fallback should be freed for XTS path.
Horia
PATCH v2 2/12 crypto: caam/qi - add fallback for XTS with more than 8B IV
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
A hardware limitation exists for CAAM until Era 9 which restricts the accelerator to IVs with only 8 bytes. When CAAM has a lower era a fallback is necessary to process 16 bytes IV.
--- drivers/crypto/caam/Kconfig | 1 + drivers/crypto/caam/caamalg_qi.c | 70 +++++++++++++++++++++++++++++--- 2 files changed, 66 insertions(+), 5 deletions(-)
drivers/crypto/caam/Kconfig +1 -0
@@ -115,6 +115,7 @@ config CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI select CRYPTO_AUTHENC select CRYPTO_SKCIPHER select CRYPTO_DES + select CRYPTO_XTS help Selecting this will use CAAM Queue Interface (QI) for sending & receiving crypto jobs to/from CAAM. This gives better performance
drivers/crypto/caam/caamalg_qi.c +65 -5
131 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v2 3/12 crypto: caam/qi2 - add fallback for XTS with more than 8B IV
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
A hardware limitation exists for CAAM until Era 9 which restricts the accelerator to IVs with only 8 bytes. When CAAM has a lower era a fallback is necessary to process 16 bytes IV.
--- drivers/crypto/caam/Kconfig | 1 + drivers/crypto/caam/caamalg_qi2.c | 78 +++++++++++++++++++++++++++++-- drivers/crypto/caam/caamalg_qi2.h | 2 + 3 files changed, 76 insertions(+), 5 deletions(-)
drivers/crypto/caam/Kconfig +1 -0
@@ -167,6 +167,7 @@ config CRYPTO_DEV_FSL_DPAA2_CAAM select CRYPTO_AEAD select CRYPTO_HASH select CRYPTO_DES + select CRYPTO_XTS help CAAM driver for QorIQ Data Path Acceleration Architecture 2. It handles DPSECI DPAA2 objects that sit on the Management Complex
drivers/crypto/caam/caamalg_qi2.c +73 -5
145 lines not on this page · raw message
drivers/crypto/caam/caamalg_qi2.h +2 -0
@@ -13,6 +13,7 @@#include <linux/netdevice.h> #include "dpseci.h" #include "desc_constr.h" +#include <crypto/skcipher.h> #define DPAA2_CAAM_STORE_SIZE 16/* NAPI weight *must* be a multiple of the store size. */
@@ -186,6 +187,7 @@ struct caam_request {void (*cbk)(void *ctx,u32 err);void *ctx;void *edesc; +struct skcipher_request fallback_req; };/**
Signature · 1 line
2.17.1
PATCH v2 4/12 crypto: caam/jr - add support for more XTS key lengths
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
CAAM accelerator only supports XTS-AES-128 and XTS-AES-256 since it adheres strictly to the standard. All the other key lengths are accepted and processed through a fallback as long as they pass the xts_verify_key() checks.
--- drivers/crypto/caam/caamalg.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
drivers/crypto/caam/caamalg.c +10 -3
@@ -57,6 +57,7 @@#include "key_gen.h" #include "caamalg_desc.h" #include <crypto/engine.h> +#include <crypto/xts.h> #include <asm/unaligned.h> /*
@@ -115,6 +116,7 @@ struct caam_ctx {struct alginfo adata;struct alginfo cdata;unsigned int authsize; +bool xts_key_fallback;struct crypto_skcipher *fallback; };
@@ -835,11 +837,15 @@ static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key,u32 *desc;int err; -if (keylen !=2 *AES_MIN_KEY_SIZE && keylen !=2 *AES_MAX_KEY_SIZE ) { + err =xts_verify_key (skcipher, key, keylen); +if (err) {dev_dbg (jrdev,"key size mismatch\n" ); -return -EINVAL ; +return err; } +if (keylen !=2 *AES_KEYSIZE_128 && keylen !=2 *AES_KEYSIZE_256 ) + ctx->xts_key_fallback = true; + err =crypto_skcipher_setkey (ctx->fallback, key, keylen);if (err)return err;
@@ -1787,7 +1793,8 @@ static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)if (!req->cryptlen)return 0 ; -if (ctx->fallback &&xts_skcipher_ivsize (req)) { +if (ctx->fallback && (xts_skcipher_ivsize (req) || + ctx->xts_key_fallback)) {struct caam_skcipher_req_ctx *rctx =skcipher_request_ctx (req);skcipher_request_set_tfm (&rctx->fallback_req, ctx->fallback);
Signature · 1 line
2.17.1
PATCH v2 5/12 crypto: caam/qi - add support for more XTS key lengths
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
CAAM accelerator only supports XTS-AES-128 and XTS-AES-256 since it adheres strictly to the standard. All the other key lengths are accepted and processed through a fallback as long as they pass the xts_verify_key() checks.
--- drivers/crypto/caam/caamalg_qi.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
drivers/crypto/caam/caamalg_qi.c +10 -3
@@ -18,6 +18,7 @@#include "qi.h" #include "jr.h" #include "caamalg_desc.h" +#include <crypto/xts.h> #include <asm/unaligned.h> /*
@@ -68,6 +69,7 @@ struct caam_ctx {struct device *qidev;spinlock_t lock;/* Protects multiple init of driver context */ struct caam_drv_ctx *drv_ctx[NUM_OP ]; +bool xts_key_fallback;struct crypto_skcipher *fallback; };
@@ -734,11 +736,15 @@ static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key,int ret =0 ;int err; -if (keylen !=2 *AES_MIN_KEY_SIZE && keylen !=2 *AES_MAX_KEY_SIZE ) { + err =xts_verify_key (skcipher, key, keylen); +if (err) {dev_dbg (jrdev,"key size mismatch\n" ); -return -EINVAL ; +return err; } +if (keylen !=2 *AES_KEYSIZE_128 && keylen !=2 *AES_KEYSIZE_256 ) + ctx->xts_key_fallback = true; + err =crypto_skcipher_setkey (ctx->fallback, key, keylen);if (err)return err;
@@ -1405,7 +1411,8 @@ static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)if (!req->cryptlen)return 0 ; -if (ctx->fallback &&xts_skcipher_ivsize (req)) { +if (ctx->fallback && (xts_skcipher_ivsize (req) || + ctx->xts_key_fallback)) {struct caam_skcipher_req_ctx *rctx =skcipher_request_ctx (req);skcipher_request_set_tfm (&rctx->fallback_req, ctx->fallback);
Signature · 1 line
2.17.1
PATCH v2 6/12 crypto: caam/qi2 - add support for more XTS key lengths
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
CAAM accelerator only supports XTS-AES-128 and XTS-AES-256 since it adheres strictly to the standard. All the other key lengths are accepted and processed through a fallback as long as they pass the xts_verify_key() checks.
--- drivers/crypto/caam/caamalg_qi2.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-)
drivers/crypto/caam/caamalg_qi2.c +12 -4
@@ -19,6 +19,7 @@#include <linux/fsl/mc.h> #include <soc/fsl/dpaa2-io.h> #include <soc/fsl/dpaa2-fd.h> +#include <crypto/xts.h> #include <asm/unaligned.h> #define CAAM_CRA_PRIORITY 2000
@@ -81,6 +82,7 @@ struct caam_ctx {struct alginfo adata;struct alginfo cdata;unsigned int authsize; +bool xts_key_fallback;struct crypto_skcipher *fallback; };
@@ -1060,11 +1062,15 @@ static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key,u32 *desc;int err; -if (keylen !=2 *AES_MIN_KEY_SIZE && keylen !=2 *AES_MAX_KEY_SIZE ) { + err =xts_verify_key (skcipher, key, keylen); +if (err) {dev_dbg (dev,"key size mismatch\n" ); -return -EINVAL ; +return err; } +if (keylen !=2 *AES_KEYSIZE_128 && keylen !=2 *AES_KEYSIZE_256 ) + ctx->xts_key_fallback = true; + err =crypto_skcipher_setkey (ctx->fallback, key, keylen);if (err)return err;
@@ -1472,7 +1478,8 @@ static int skcipher_encrypt(struct skcipher_request *req)if (!req->cryptlen)return 0 ; -if (ctx->fallback &&xts_skcipher_ivsize (req)) { +if (ctx->fallback && (xts_skcipher_ivsize (req) || + ctx->xts_key_fallback)) {skcipher_request_set_tfm (&caam_req->fallback_req, ctx->fallback); skcipher_request_set_callback(&caam_req->fallback_req, req->base.flags,
@@ -1515,7 +1522,8 @@ static int skcipher_decrypt(struct skcipher_request *req)if (!req->cryptlen)return 0 ; -if (ctx->fallback &&xts_skcipher_ivsize (req)) { +if (ctx->fallback && (xts_skcipher_ivsize (req) || + ctx->xts_key_fallback)) {skcipher_request_set_tfm (&caam_req->fallback_req, ctx->fallback); skcipher_request_set_callback(&caam_req->fallback_req, req->base.flags,
Signature · 1 line
2.17.1
PATCH v2 7/12 crypto: caam/jr - add xts check for block length equal to zero
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
XTS should not return succes when dealing with block length equal to zero. This is different than the rest of the skcipher algorithms.
--- drivers/crypto/caam/caamalg.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/crypto/caam/caamalg.c +6 -1
@@ -1790,7 +1790,12 @@ static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)u32 *desc;int ret =0 ; -if (!req->cryptlen) +/* +* XTS is expected to return an error even for input length = 0 +* Note that the case input length < block size will be caught during +* HW offloading and return an error. +*/ +if (!req->cryptlen && !ctx->fallback)return 0 ; if (ctx->fallback && (xts_skcipher_ivsize(req) ||
Signature · 1 line
2.17.1
PATCH v2 8/12 crypto: caam/qi - add xts check for block length equal to zero
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
XTS should not return succes when dealing with block length equal to zero. This is different than the rest of the skcipher algorithms.
--- drivers/crypto/caam/caamalg_qi.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/crypto/caam/caamalg_qi.c +6 -1
@@ -1408,7 +1408,12 @@ static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)struct caam_ctx *ctx =crypto_skcipher_ctx (skcipher);int ret; -if (!req->cryptlen) +/* +* XTS is expected to return an error even for input length = 0 +* Note that the case input length < block size will be caught during +* HW offloading and return an error. +*/ +if (!req->cryptlen && !ctx->fallback)return 0 ; if (ctx->fallback && (xts_skcipher_ivsize(req) ||
Signature · 1 line
2.17.1
PATCH v2 9/12 crypto: caam/qi2 - add xts check for block length equal to zero
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
XTS should not return succes when dealing with block length equal to zero. This is different than the rest of the skcipher algorithms.
--- drivers/crypto/caam/caamalg_qi2.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)
drivers/crypto/caam/caamalg_qi2.c +12 -2
@@ -1475,7 +1475,12 @@ static int skcipher_encrypt(struct skcipher_request *req)struct caam_request *caam_req =skcipher_request_ctx (req);int ret; -if (!req->cryptlen) +/* +* XTS is expected to return an error even for input length = 0 +* Note that the case input length < block size will be caught during +* HW offloading and return an error. +*/ +if (!req->cryptlen && !ctx->fallback)return 0 ; if (ctx->fallback && (xts_skcipher_ivsize(req) ||
@@ -1519,7 +1524,12 @@ static int skcipher_decrypt(struct skcipher_request *req)struct caam_request *caam_req =skcipher_request_ctx (req);int ret; -if (!req->cryptlen) +/* +* XTS is expected to return an error even for input length = 0 +* Note that the case input length < block size will be caught during +* HW offloading and return an error. +*/ +if (!req->cryptlen && !ctx->fallback)return 0 ; if (ctx->fallback && (xts_skcipher_ivsize(req) ||
Signature · 1 line
2.17.1
PATCH v2 10/12 crypto: caam/jr - add support for XTS with 16B IV
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
Newer CAAM versions (Era 9+) support 16B IVs. Since for these devices the HW limitation is no longer present newer version should process the requests containing 16B IVs directly in hardware without using a fallback.
--- drivers/crypto/caam/caamalg.c | 12 ++++++++---- drivers/crypto/caam/caamalg_desc.c | 27 ++++++++++++++++----------- 2 files changed, 24 insertions(+), 15 deletions(-)
drivers/crypto/caam/caamalg.c +8 -4
@@ -834,6 +834,7 @@ static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key, {struct caam_ctx *ctx =crypto_skcipher_ctx (skcipher);struct device *jrdev = ctx->jrdev; +struct caam_drv_private *ctrlpriv =dev_get_drvdata (jrdev->parent);u32 *desc;int err;
@@ -846,9 +847,11 @@ static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key,if (keylen !=2 *AES_KEYSIZE_128 && keylen !=2 *AES_KEYSIZE_256 ) ctx->xts_key_fallback = true; - err =crypto_skcipher_setkey (ctx->fallback, key, keylen); -if (err) -return err; +if (ctrlpriv->era <=8 || ctx->xts_key_fallback) { + err =crypto_skcipher_setkey (ctx->fallback, key, keylen); +if (err) +return err; + } ctx->cdata.keylen = keylen; ctx->cdata.key_virt = key;
@@ -1787,6 +1790,7 @@ static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)struct caam_ctx *ctx =crypto_skcipher_ctx (skcipher);struct device *jrdev = ctx->jrdev;struct caam_drv_private_jr *jrpriv =dev_get_drvdata (jrdev); +struct caam_drv_private *ctrlpriv =dev_get_drvdata (jrdev->parent);u32 *desc;int ret =0 ;
@@ -1798,7 +1802,7 @@ static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)if (!req->cryptlen && !ctx->fallback)return 0 ; -if (ctx->fallback && (xts_skcipher_ivsize (req) || +if (ctx->fallback && ((ctrlpriv->era <=8 &&xts_skcipher_ivsize (req)) || ctx->xts_key_fallback)) {struct caam_skcipher_req_ctx *rctx =skcipher_request_ctx (req);
drivers/crypto/caam/caamalg_desc.c +16 -11
@@ -1550,13 +1550,14 @@ void cnstr_shdsc_xts_skcipher_encap(u32 * const desc, struct alginfo *cdata)set_jump_tgt_here (desc, key_jump_cmd);/* -* create sequence for loading the sector index -* Upper 8B of IV - will be used as sector index -* Lower 8B of IV - will be discarded +* create sequence for loading the sector index / 16B tweak value +* Lower 8B of IV - sector index / tweak lower half +* Upper 8B of IV - upper half of 16B tweak */ append_seq_load (desc,8 ,LDST_SRCDST_BYTE_CONTEXT |LDST_CLASS_1_CCB | (0x20 <<LDST_OFFSET_SHIFT )); -append_seq_fifo_load (desc,8 ,FIFOLD_CLASS_SKIP ); +append_seq_load (desc,8 ,LDST_SRCDST_BYTE_CONTEXT |LDST_CLASS_1_CCB | + (0x30 <<LDST_OFFSET_SHIFT ));/* Load operation */ append_operation(desc, cdata->algtype | OP_ALG_AS_INITFINAL |
@@ -1565,9 +1566,11 @@ void cnstr_shdsc_xts_skcipher_encap(u32 * const desc, struct alginfo *cdata)/* Perform operation */ skcipher_append_src_dst (desc); -/* Store upper 8B of IV */ +/* Store lower 8B and upper 8B of IV */ append_seq_store (desc,8 ,LDST_SRCDST_BYTE_CONTEXT |LDST_CLASS_1_CCB | (0x20 <<LDST_OFFSET_SHIFT )); +append_seq_store (desc,8 ,LDST_SRCDST_BYTE_CONTEXT |LDST_CLASS_1_CCB | + (0x30 <<LDST_OFFSET_SHIFT )); print_hex_dump_debug("xts skcipher enc shdesc@" __stringify(__LINE__) ": ", DUMP_PREFIX_ADDRESS, 16, 4,
@@ -1609,23 +1612,25 @@ void cnstr_shdsc_xts_skcipher_decap(u32 * const desc, struct alginfo *cdata)set_jump_tgt_here (desc, key_jump_cmd);/* -* create sequence for loading the sector index -* Upper 8B of IV - will be used as sector index -* Lower 8B of IV - will be discarded +* create sequence for loading the sector index / 16B tweak value +* Lower 8B of IV - sector index / tweak lower half +* Upper 8B of IV - upper half of 16B tweak */ append_seq_load (desc,8 ,LDST_SRCDST_BYTE_CONTEXT |LDST_CLASS_1_CCB | (0x20 <<LDST_OFFSET_SHIFT )); -append_seq_fifo_load (desc,8 ,FIFOLD_CLASS_SKIP ); - +append_seq_load (desc,8 ,LDST_SRCDST_BYTE_CONTEXT |LDST_CLASS_1_CCB | + (0x30 <<LDST_OFFSET_SHIFT ));/* Load operation */ append_dec_op1 (desc, cdata->algtype);/* Perform operation */ skcipher_append_src_dst (desc); -/* Store upper 8B of IV */ +/* Store lower 8B and upper 8B of IV */ append_seq_store (desc,8 ,LDST_SRCDST_BYTE_CONTEXT |LDST_CLASS_1_CCB | (0x20 <<LDST_OFFSET_SHIFT )); +append_seq_store (desc,8 ,LDST_SRCDST_BYTE_CONTEXT |LDST_CLASS_1_CCB | + (0x30 <<LDST_OFFSET_SHIFT )); print_hex_dump_debug("xts skcipher dec shdesc@" __stringify(__LINE__) ": ", DUMP_PREFIX_ADDRESS, 16, 4, desc,
Signature · 1 line
2.17.1
PATCH v2 11/12 crypto: caam/qi - add support for XTS with 16B IV
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
Newer CAAM versions (Era 9+) support 16B IVs. Since for these devices the HW limitation is no longer present newer version should process the requests containing 16B IVs directly in hardware without using a fallback.
--- drivers/crypto/caam/caamalg_qi.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
drivers/crypto/caam/caamalg_qi.c +8 -4
@@ -733,6 +733,7 @@ static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key, {struct caam_ctx *ctx =crypto_skcipher_ctx (skcipher);struct device *jrdev = ctx->jrdev; +struct caam_drv_private *ctrlpriv =dev_get_drvdata (jrdev->parent);int ret =0 ;int err;
@@ -745,9 +746,11 @@ static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key,if (keylen !=2 *AES_KEYSIZE_128 && keylen !=2 *AES_KEYSIZE_256 ) ctx->xts_key_fallback = true; - err =crypto_skcipher_setkey (ctx->fallback, key, keylen); -if (err) -return err; +if (ctrlpriv->era <=8 || ctx->xts_key_fallback) { + err =crypto_skcipher_setkey (ctx->fallback, key, keylen); +if (err) +return err; + } ctx->cdata.keylen = keylen; ctx->cdata.key_virt = key;
@@ -1406,6 +1409,7 @@ static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)struct skcipher_edesc *edesc;struct crypto_skcipher *skcipher =crypto_skcipher_reqtfm (req);struct caam_ctx *ctx =crypto_skcipher_ctx (skcipher); +struct caam_drv_private *ctrlpriv =dev_get_drvdata (ctx->jrdev->parent);int ret;/*
@@ -1416,7 +1420,7 @@ static inline int skcipher_crypt(struct skcipher_request *req, bool encrypt)if (!req->cryptlen && !ctx->fallback)return 0 ; -if (ctx->fallback && (xts_skcipher_ivsize (req) || +if (ctx->fallback && ((ctrlpriv->era <=8 &&xts_skcipher_ivsize (req)) || ctx->xts_key_fallback)) {struct caam_skcipher_req_ctx *rctx =skcipher_request_ctx (req);
Signature · 1 line
2.17.1
PATCH v2 12/12 crypto: caam/qi2 - add support for XTS with 16B IV
In reply to Andrei BotilaFrom: Andrei Botila <[email protected]>
Newer CAAM versions (Era 9+) support 16B IVs. Since for these devices the HW limitation is no longer present newer version should process the requests containing 16B IVs directly in hardware without using a fallback.
--- drivers/crypto/caam/caamalg_qi2.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-)
drivers/crypto/caam/caamalg_qi2.c +10 -5
@@ -1058,6 +1058,7 @@ static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key, {struct caam_ctx *ctx =crypto_skcipher_ctx (skcipher);struct device *dev = ctx->dev; +struct dpaa2_caam_priv *priv =dev_get_drvdata (dev);struct caam_flc *flc;u32 *desc;int err;
@@ -1071,9 +1072,11 @@ static int xts_skcipher_setkey(struct crypto_skcipher *skcipher, const u8 *key,if (keylen !=2 *AES_KEYSIZE_128 && keylen !=2 *AES_KEYSIZE_256 ) ctx->xts_key_fallback = true; - err =crypto_skcipher_setkey (ctx->fallback, key, keylen); -if (err) -return err; +if (priv->sec_attr.era <=8 || ctx->xts_key_fallback) { + err =crypto_skcipher_setkey (ctx->fallback, key, keylen); +if (err) +return err; + } ctx->cdata.keylen = keylen; ctx->cdata.key_virt = key;
@@ -1473,6 +1476,7 @@ static int skcipher_encrypt(struct skcipher_request *req)struct crypto_skcipher *skcipher =crypto_skcipher_reqtfm (req);struct caam_ctx *ctx =crypto_skcipher_ctx (skcipher);struct caam_request *caam_req =skcipher_request_ctx (req); +struct dpaa2_caam_priv *priv =dev_get_drvdata (ctx->dev);int ret;/*
@@ -1483,7 +1487,7 @@ static int skcipher_encrypt(struct skcipher_request *req)if (!req->cryptlen && !ctx->fallback)return 0 ; -if (ctx->fallback && (xts_skcipher_ivsize (req) || +if (ctx->fallback && ((priv->sec_attr.era <=8 &&xts_skcipher_ivsize (req)) || ctx->xts_key_fallback)) {skcipher_request_set_tfm (&caam_req->fallback_req, ctx->fallback); skcipher_request_set_callback(&caam_req->fallback_req,
@@ -1522,6 +1526,7 @@ static int skcipher_decrypt(struct skcipher_request *req)struct crypto_skcipher *skcipher =crypto_skcipher_reqtfm (req);struct caam_ctx *ctx =crypto_skcipher_ctx (skcipher);struct caam_request *caam_req =skcipher_request_ctx (req); +struct dpaa2_caam_priv *priv =dev_get_drvdata (ctx->dev);int ret;/*
@@ -1532,7 +1537,7 @@ static int skcipher_decrypt(struct skcipher_request *req)if (!req->cryptlen && !ctx->fallback)return 0 ; -if (ctx->fallback && (xts_skcipher_ivsize (req) || +if (ctx->fallback && ((priv->sec_attr.era <=8 &&xts_skcipher_ivsize (req)) || ctx->xts_key_fallback)) {skcipher_request_set_tfm (&caam_req->fallback_req, ctx->fallback); skcipher_request_set_callback(&caam_req->fallback_req,
Signature · 1 line
2.17.1
Horia Geantă
maintainerQuoted 8 lines · Andrei Botila (OSS)
From: Andrei Botila <[email protected]>
This patch series fixes some problems in CAAM's implementation of xts(aes):
- CAAM until Era 9 can't process XTS with 16B IV
- CAAM can only process in hardware XTS key lengths of 16B and 32B
- These hardware limitations are resolved through a fallback
- CAAM used to return 0 for XTS block length equal to zero
Quoted 9 lines
This patch series also adds a new feature in CAAM's xts(aes):
- CAAM is now able to process XTS with 16B IV in HWChanges since v1:
- use onlyget_unaligned()for calculating XTS IV size
- fixed the double calling ofcrypto_skcipher_set_reqsize()in case of XTS
- added a patch which modifies the return value for XTS when block length is equal to zero
Nitpick:
The new patches are 7-9/12.
Since they have the same Fixes tag and solve the same issue, it would probably be better to squash them into a single patch.
Thanks,
Horia