aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorEric Biggers <ebiggers@google.com>2018-02-20 02:48:15 -0500
committerHerbert Xu <herbert@gondor.apana.org.au>2018-03-02 11:03:28 -0500
commit4bd969243143e224d5aa450fdea1c882a75aa58e (patch)
treeaf3056d17ac2eec2789bf9f86353b84dc579be58
parentf51a1fa43972c93e08a608df51182d90ab8d7594 (diff)
crypto: x86/cast6-avx - convert to skcipher interface
Convert the AVX implementation of CAST6 from the (deprecated) ablkcipher and blkcipher interfaces over to the skcipher interface. Note that this includes replacing the use of ablk_helper with crypto_simd. Signed-off-by: Eric Biggers <ebiggers@google.com> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Diffstat
-rw-r--r--arch/x86/crypto/cast6_avx_glue.c311
-rw-r--r--crypto/Kconfig9
2 files changed, 104 insertions, 216 deletions
diff --git a/arch/x86/crypto/cast6_avx_glue.c b/arch/x86/crypto/cast6_avx_glue.c
index d2fbf2be771e..9fb66b5e94b2 100644
--- a/arch/x86/crypto/cast6_avx_glue.c
+++ b/arch/x86/crypto/cast6_avx_glue.c
@@ -24,16 +24,12 @@
24 */ 24 */
25 25
26#include <linux/module.h> 26#include <linux/module.h>
27#include <linux/hardirq.h>
28#include <linux/types.h> 27#include <linux/types.h>
29#include <linux/crypto.h> 28#include <linux/crypto.h>
30#include <linux/err.h> 29#include <linux/err.h>
31#include <crypto/ablk_helper.h>
32#include <crypto/algapi.h> 30#include <crypto/algapi.h>
33#include <crypto/cast6.h> 31#include <crypto/cast6.h>
34#include <crypto/cryptd.h> 32#include <crypto/internal/simd.h>
35#include <crypto/b128ops.h>
36#include <crypto/ctr.h>
37#include <crypto/xts.h> 33#include <crypto/xts.h>
38#include <asm/crypto/glue_helper.h> 34#include <asm/crypto/glue_helper.h>
39 35
@@ -54,6 +50,12 @@ asmlinkage void cast6_xts_enc_8way(struct cast6_ctx *ctx, u8 *dst,
54asmlinkage void cast6_xts_dec_8way(struct cast6_ctx *ctx, u8 *dst, 50asmlinkage void cast6_xts_dec_8way(struct cast6_ctx *ctx, u8 *dst,
55 const u8 *src, le128 *iv); 51 const u8 *src, le128 *iv);
56 52
53static int cast6_setkey_skcipher(struct crypto_skcipher *tfm,
54 const u8 *key, unsigned int keylen)
55{
56 return cast6_setkey(&tfm->base, key, keylen);
57}
58
57static void cast6_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv) 59static void cast6_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv)
58{ 60{
59 glue_xts_crypt_128bit_one(ctx, dst, src, iv, 61 glue_xts_crypt_128bit_one(ctx, dst, src, iv,
@@ -155,36 +157,30 @@ static const struct common_glue_ctx cast6_dec_xts = {
155 } } 157 } }
156}; 158};
157 159
158static int ecb_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 160static int ecb_encrypt(struct skcipher_request *req)
159 struct scatterlist *src, unsigned int nbytes)
160{ 161{
161 return glue_ecb_crypt_128bit(&cast6_enc, desc, dst, src, nbytes); 162 return glue_ecb_req_128bit(&cast6_enc, req);
162} 163}
163 164
164static int ecb_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 165static int ecb_decrypt(struct skcipher_request *req)
165 struct scatterlist *src, unsigned int nbytes)
166{ 166{
167 return glue_ecb_crypt_128bit(&cast6_dec, desc, dst, src, nbytes); 167 return glue_ecb_req_128bit(&cast6_dec, req);
168} 168}
169 169
170static int cbc_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 170static int cbc_encrypt(struct skcipher_request *req)
171 struct scatterlist *src, unsigned int nbytes)
172{ 171{
173 return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__cast6_encrypt), desc, 172 return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__cast6_encrypt),
174 dst, src, nbytes); 173 req);
175} 174}
176 175
177static int cbc_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 176static int cbc_decrypt(struct skcipher_request *req)
178 struct scatterlist *src, unsigned int nbytes)
179{ 177{
180 return glue_cbc_decrypt_128bit(&cast6_dec_cbc, desc, dst, src, 178 return glue_cbc_decrypt_req_128bit(&cast6_dec_cbc, req);
181 nbytes);
182} 179}
183 180
184static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst, 181static int ctr_crypt(struct skcipher_request *req)
185 struct scatterlist *src, unsigned int nbytes)
186{ 182{
187 return glue_ctr_crypt_128bit(&cast6_ctr, desc, dst, src, nbytes); 183 return glue_ctr_req_128bit(&cast6_ctr, req);
188} 184}
189 185
190struct cast6_xts_ctx { 186struct cast6_xts_ctx {
@@ -192,14 +188,14 @@ struct cast6_xts_ctx {
192 struct cast6_ctx crypt_ctx; 188 struct cast6_ctx crypt_ctx;
193}; 189};
194 190
195static int xts_cast6_setkey(struct crypto_tfm *tfm, const u8 *key, 191static int xts_cast6_setkey(struct crypto_skcipher *tfm, const u8 *key,
196 unsigned int keylen) 192 unsigned int keylen)
197{ 193{
198 struct cast6_xts_ctx *ctx = crypto_tfm_ctx(tfm); 194 struct cast6_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
199 u32 *flags = &tfm->crt_flags; 195 u32 *flags = &tfm->base.crt_flags;
200 int err; 196 int err;
201 197
202 err = xts_check_key(tfm, key, keylen); 198 err = xts_verify_key(tfm, key, keylen);
203 if (err) 199 if (err)
204 return err; 200 return err;
205 201
@@ -213,197 +209,87 @@ static int xts_cast6_setkey(struct crypto_tfm *tfm, const u8 *key,
213 flags); 209 flags);
214} 210}
215 211
216static int xts_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 212static int xts_encrypt(struct skcipher_request *req)
217 struct scatterlist *src, unsigned int nbytes)
218{ 213{
219 struct cast6_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 214 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
215 struct cast6_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
220 216
221 return glue_xts_crypt_128bit(&cast6_enc_xts, desc, dst, src, nbytes, 217 return glue_xts_req_128bit(&cast6_enc_xts, req,
222 XTS_TWEAK_CAST(__cast6_encrypt), 218 XTS_TWEAK_CAST(__cast6_encrypt),
223 &ctx->tweak_ctx, &ctx->crypt_ctx); 219 &ctx->tweak_ctx, &ctx->crypt_ctx);
224} 220}
225 221
226static int xts_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 222static int xts_decrypt(struct skcipher_request *req)
227 struct scatterlist *src, unsigned int nbytes)
228{ 223{
229 struct cast6_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 224 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
225 struct cast6_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
230 226
231 return glue_xts_crypt_128bit(&cast6_dec_xts, desc, dst, src, nbytes, 227 return glue_xts_req_128bit(&cast6_dec_xts, req,
232 XTS_TWEAK_CAST(__cast6_encrypt), 228 XTS_TWEAK_CAST(__cast6_encrypt),
233 &ctx->tweak_ctx, &ctx->crypt_ctx); 229 &ctx->tweak_ctx, &ctx->crypt_ctx);
234} 230}
235 231
236static struct crypto_alg cast6_algs[] = { { 232static struct skcipher_alg cast6_algs[] = {
237 .cra_name = "__ecb-cast6-avx", 233 {
238 .cra_driver_name = "__driver-ecb-cast6-avx", 234 .base.cra_name = "__ecb(cast6)",
239 .cra_priority = 0, 235 .base.cra_driver_name = "__ecb-cast6-avx",
240 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 236 .base.cra_priority = 200,
241 CRYPTO_ALG_INTERNAL, 237 .base.cra_flags = CRYPTO_ALG_INTERNAL,
242 .cra_blocksize = CAST6_BLOCK_SIZE, 238 .base.cra_blocksize = CAST6_BLOCK_SIZE,
243 .cra_ctxsize = sizeof(struct cast6_ctx), 239 .base.cra_ctxsize = sizeof(struct cast6_ctx),
244 .cra_alignmask = 0, 240 .base.cra_module = THIS_MODULE,
245 .cra_type = &crypto_blkcipher_type, 241 .min_keysize = CAST6_MIN_KEY_SIZE,
246 .cra_module = THIS_MODULE, 242 .max_keysize = CAST6_MAX_KEY_SIZE,
247 .cra_u = { 243 .setkey = cast6_setkey_skcipher,
248 .blkcipher = { 244 .encrypt = ecb_encrypt,
249 .min_keysize = CAST6_MIN_KEY_SIZE, 245 .decrypt = ecb_decrypt,
250 .max_keysize = CAST6_MAX_KEY_SIZE, 246 }, {
251 .setkey = cast6_setkey, 247 .base.cra_name = "__cbc(cast6)",
252 .encrypt = ecb_encrypt, 248 .base.cra_driver_name = "__cbc-cast6-avx",
253 .decrypt = ecb_decrypt, 249 .base.cra_priority = 200,
254 }, 250 .base.cra_flags = CRYPTO_ALG_INTERNAL,
255 }, 251 .base.cra_blocksize = CAST6_BLOCK_SIZE,
256}, { 252 .base.cra_ctxsize = sizeof(struct cast6_ctx),
257 .cra_name = "__cbc-cast6-avx", 253 .base.cra_module = THIS_MODULE,
258 .cra_driver_name = "__driver-cbc-cast6-avx", 254 .min_keysize = CAST6_MIN_KEY_SIZE,
259 .cra_priority = 0, 255 .max_keysize = CAST6_MAX_KEY_SIZE,
260 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 256 .ivsize = CAST6_BLOCK_SIZE,
261 CRYPTO_ALG_INTERNAL, 257 .setkey = cast6_setkey_skcipher,
262 .cra_blocksize = CAST6_BLOCK_SIZE, 258 .encrypt = cbc_encrypt,
263 .cra_ctxsize = sizeof(struct cast6_ctx), 259 .decrypt = cbc_decrypt,
264 .cra_alignmask = 0, 260 }, {
265 .cra_type = &crypto_blkcipher_type, 261 .base.cra_name = "__ctr(cast6)",
266 .cra_module = THIS_MODULE, 262 .base.cra_driver_name = "__ctr-cast6-avx",
267 .cra_u = { 263 .base.cra_priority = 200,
268 .blkcipher = { 264 .base.cra_flags = CRYPTO_ALG_INTERNAL,
269 .min_keysize = CAST6_MIN_KEY_SIZE, 265 .base.cra_blocksize = 1,
270 .max_keysize = CAST6_MAX_KEY_SIZE, 266 .base.cra_ctxsize = sizeof(struct cast6_ctx),
271 .setkey = cast6_setkey, 267 .base.cra_module = THIS_MODULE,
272 .encrypt = cbc_encrypt, 268 .min_keysize = CAST6_MIN_KEY_SIZE,
273 .decrypt = cbc_decrypt, 269 .max_keysize = CAST6_MAX_KEY_SIZE,
274 }, 270 .ivsize = CAST6_BLOCK_SIZE,
275 }, 271 .chunksize = CAST6_BLOCK_SIZE,
276}, { 272 .setkey = cast6_setkey_skcipher,
277 .cra_name = "__ctr-cast6-avx", 273 .encrypt = ctr_crypt,
278 .cra_driver_name = "__driver-ctr-cast6-avx", 274 .decrypt = ctr_crypt,
279 .cra_priority = 0, 275 }, {
280 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 276 .base.cra_name = "__xts(cast6)",
281 CRYPTO_ALG_INTERNAL, 277 .base.cra_driver_name = "__xts-cast6-avx",
282 .cra_blocksize = 1, 278 .base.cra_priority = 200,
283 .cra_ctxsize = sizeof(struct cast6_ctx), 279 .base.cra_flags = CRYPTO_ALG_INTERNAL,
284 .cra_alignmask = 0, 280 .base.cra_blocksize = CAST6_BLOCK_SIZE,
285 .cra_type = &crypto_blkcipher_type, 281 .base.cra_ctxsize = sizeof(struct cast6_xts_ctx),
286 .cra_module = THIS_MODULE, 282 .base.cra_module = THIS_MODULE,
287 .cra_u = { 283 .min_keysize = 2 * CAST6_MIN_KEY_SIZE,
288 .blkcipher = { 284 .max_keysize = 2 * CAST6_MAX_KEY_SIZE,
289 .min_keysize = CAST6_MIN_KEY_SIZE, 285 .ivsize = CAST6_BLOCK_SIZE,
290 .max_keysize = CAST6_MAX_KEY_SIZE, 286 .setkey = xts_cast6_setkey,
291 .ivsize = CAST6_BLOCK_SIZE, 287 .encrypt = xts_encrypt,
292 .setkey = cast6_setkey, 288 .decrypt = xts_decrypt,
293 .encrypt = ctr_crypt,
294 .decrypt = ctr_crypt,
295 },
296 },
297}, {
298 .cra_name = "__xts-cast6-avx",
299 .cra_driver_name = "__driver-xts-cast6-avx",
300 .cra_priority = 0,
301 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER |
302 CRYPTO_ALG_INTERNAL,
303 .cra_blocksize = CAST6_BLOCK_SIZE,
304 .cra_ctxsize = sizeof(struct cast6_xts_ctx),
305 .cra_alignmask = 0,
306 .cra_type = &crypto_blkcipher_type,
307 .cra_module = THIS_MODULE,
308 .cra_u = {
309 .blkcipher = {
310 .min_keysize = CAST6_MIN_KEY_SIZE * 2,
311 .max_keysize = CAST6_MAX_KEY_SIZE * 2,
312 .ivsize = CAST6_BLOCK_SIZE,
313 .setkey = xts_cast6_setkey,
314 .encrypt = xts_encrypt,
315 .decrypt = xts_decrypt,
316 },
317 },
318}, {
319 .cra_name = "ecb(cast6)",
320 .cra_driver_name = "ecb-cast6-avx",
321 .cra_priority = 200,
322 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
323 .cra_blocksize = CAST6_BLOCK_SIZE,
324 .cra_ctxsize = sizeof(struct async_helper_ctx),
325 .cra_alignmask = 0,
326 .cra_type = &crypto_ablkcipher_type,
327 .cra_module = THIS_MODULE,
328 .cra_init = ablk_init,
329 .cra_exit = ablk_exit,
330 .cra_u = {
331 .ablkcipher = {
332 .min_keysize = CAST6_MIN_KEY_SIZE,
333 .max_keysize = CAST6_MAX_KEY_SIZE,
334 .setkey = ablk_set_key,
335 .encrypt = ablk_encrypt,
336 .decrypt = ablk_decrypt,
337 },
338 },
339}, {
340 .cra_name = "cbc(cast6)",
341 .cra_driver_name = "cbc-cast6-avx",
342 .cra_priority = 200,
343 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
344 .cra_blocksize = CAST6_BLOCK_SIZE,
345 .cra_ctxsize = sizeof(struct async_helper_ctx),
346 .cra_alignmask = 0,
347 .cra_type = &crypto_ablkcipher_type,
348 .cra_module = THIS_MODULE,
349 .cra_init = ablk_init,
350 .cra_exit = ablk_exit,
351 .cra_u = {
352 .ablkcipher = {
353 .min_keysize = CAST6_MIN_KEY_SIZE,
354 .max_keysize = CAST6_MAX_KEY_SIZE,
355 .ivsize = CAST6_BLOCK_SIZE,
356 .setkey = ablk_set_key,
357 .encrypt = __ablk_encrypt,
358 .decrypt = ablk_decrypt,
359 },
360 },
361}, {
362 .cra_name = "ctr(cast6)",
363 .cra_driver_name = "ctr-cast6-avx",
364 .cra_priority = 200,
365 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
366 .cra_blocksize = 1,
367 .cra_ctxsize = sizeof(struct async_helper_ctx),
368 .cra_alignmask = 0,
369 .cra_type = &crypto_ablkcipher_type,
370 .cra_module = THIS_MODULE,
371 .cra_init = ablk_init,
372 .cra_exit = ablk_exit,
373 .cra_u = {
374 .ablkcipher = {
375 .min_keysize = CAST6_MIN_KEY_SIZE,
376 .max_keysize = CAST6_MAX_KEY_SIZE,
377 .ivsize = CAST6_BLOCK_SIZE,
378 .setkey = ablk_set_key,
379 .encrypt = ablk_encrypt,
380 .decrypt = ablk_encrypt,
381 .geniv = "chainiv",
382 },
383 },
384}, {
385 .cra_name = "xts(cast6)",
386 .cra_driver_name = "xts-cast6-avx",
387 .cra_priority = 200,
388 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
389 .cra_blocksize = CAST6_BLOCK_SIZE,
390 .cra_ctxsize = sizeof(struct async_helper_ctx),
391 .cra_alignmask = 0,
392 .cra_type = &crypto_ablkcipher_type,
393 .cra_module = THIS_MODULE,
394 .cra_init = ablk_init,
395 .cra_exit = ablk_exit,
396 .cra_u = {
397 .ablkcipher = {
398 .min_keysize = CAST6_MIN_KEY_SIZE * 2,
399 .max_keysize = CAST6_MAX_KEY_SIZE * 2,
400 .ivsize = CAST6_BLOCK_SIZE,
401 .setkey = ablk_set_key,
402 .encrypt = ablk_encrypt,
403 .decrypt = ablk_decrypt,
404 },
405 }, 289 },
406} }; 290};
291
292static struct simd_skcipher_alg *cast6_simd_algs[ARRAY_SIZE(cast6_algs)];
407 293
408static int __init cast6_init(void) 294static int __init cast6_init(void)
409{ 295{
@@ -415,12 +301,15 @@ static int __init cast6_init(void)
415 return -ENODEV; 301 return -ENODEV;
416 } 302 }
417 303
418 return crypto_register_algs(cast6_algs, ARRAY_SIZE(cast6_algs)); 304 return simd_register_skciphers_compat(cast6_algs,
305 ARRAY_SIZE(cast6_algs),
306 cast6_simd_algs);
419} 307}
420 308
421static void __exit cast6_exit(void) 309static void __exit cast6_exit(void)
422{ 310{
423 crypto_unregister_algs(cast6_algs, ARRAY_SIZE(cast6_algs)); 311 simd_unregister_skciphers(cast6_algs, ARRAY_SIZE(cast6_algs),
312 cast6_simd_algs);
424} 313}
425 314
426module_init(cast6_init); 315module_init(cast6_init);
diff --git a/crypto/Kconfig b/crypto/Kconfig
index 1e5ee62a11f6..536a7fac205f 100644
--- a/crypto/Kconfig
+++ b/crypto/Kconfig
@@ -1260,12 +1260,11 @@ config CRYPTO_CAST6
1260config CRYPTO_CAST6_AVX_X86_64 1260config CRYPTO_CAST6_AVX_X86_64
1261 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)" 1261 tristate "CAST6 (CAST-256) cipher algorithm (x86_64/AVX)"
1262 depends on X86 && 64BIT 1262 depends on X86 && 64BIT
1263 select CRYPTO_ALGAPI 1263 select CRYPTO_BLKCIPHER
1264 select CRYPTO_CRYPTD
1265 select CRYPTO_ABLK_HELPER
1266 select CRYPTO_GLUE_HELPER_X86
1267 select CRYPTO_CAST_COMMON
1268 select CRYPTO_CAST6 1264 select CRYPTO_CAST6
1265 select CRYPTO_CAST_COMMON
1266 select CRYPTO_GLUE_HELPER_X86
1267 select CRYPTO_SIMD
1269 select CRYPTO_XTS 1268 select CRYPTO_XTS
1270 help 1269 help
1271 The CAST6 encryption algorithm (synonymous with CAST-256) is 1270 The CAST6 encryption algorithm (synonymous with CAST-256) is
generated by cgit v1.2.2 (git 2.25.0) at 2026-05-27 14:45:47 -0400