crypto: x86/serpent-avx,avx2 - convert to skcipher interface

+97 -207

arch/x86/crypto/serpent_avx2_glue.c

··· 14 14 #include <linux/types.h> 15 15 #include <linux/crypto.h> 16 16 #include <linux/err.h> 17 - #include <crypto/ablk_helper.h> 18 17 #include <crypto/algapi.h> 19 - #include <crypto/ctr.h> 20 - #include <crypto/lrw.h> 21 - #include <crypto/xts.h> 18 + #include <crypto/internal/simd.h> 22 19 #include <crypto/serpent.h> 23 - #include <asm/fpu/api.h> 24 - #include <asm/crypto/serpent-avx.h> 20 + #include <crypto/xts.h> 25 21 #include <asm/crypto/glue_helper.h> 22 + #include <asm/crypto/serpent-avx.h> 26 23 27 24 #define SERPENT_AVX2_PARALLEL_BLOCKS 16 28 25 ··· 36 39 const u8 *src, le128 *iv); 37 40 asmlinkage void serpent_xts_dec_16way(struct serpent_ctx *ctx, u8 *dst, 38 41 const u8 *src, le128 *iv); 42 + 43 + static int serpent_setkey_skcipher(struct crypto_skcipher *tfm, 44 + const u8 *key, unsigned int keylen) 45 + { 46 + return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen); 47 + } 39 48 40 49 static const struct common_glue_ctx serpent_enc = { 41 50 .num_funcs = 3, ··· 139 136 } } 140 137 }; 141 138 142 - static int ecb_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 143 - struct scatterlist *src, unsigned int nbytes) 139 + static int ecb_encrypt(struct skcipher_request *req) 144 140 { 145 - return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes); 141 + return glue_ecb_req_128bit(&serpent_enc, req); 146 142 } 147 143 148 - static int ecb_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 149 - struct scatterlist *src, unsigned int nbytes) 144 + static int ecb_decrypt(struct skcipher_request *req) 150 145 { 151 - return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes); 146 + return glue_ecb_req_128bit(&serpent_dec, req); 152 147 } 153 148 154 - static int cbc_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 155 - struct scatterlist *src, unsigned int nbytes) 149 + static int cbc_encrypt(struct skcipher_request *req) 156 150 { 157 - return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc, 158 - dst, src, nbytes); 151 + return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__serpent_encrypt), 152 + req); 159 153 } 160 154 161 - static int cbc_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 162 - struct scatterlist *src, unsigned int nbytes) 155 + static int cbc_decrypt(struct skcipher_request *req) 163 156 { 164 - return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src, 165 - nbytes); 157 + return glue_cbc_decrypt_req_128bit(&serpent_dec_cbc, req); 166 158 } 167 159 168 - static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst, 169 - struct scatterlist *src, unsigned int nbytes) 160 + static int ctr_crypt(struct skcipher_request *req) 170 161 { 171 - return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes); 162 + return glue_ctr_req_128bit(&serpent_ctr, req); 172 163 } 173 164 174 - static int xts_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 175 - struct scatterlist *src, unsigned int nbytes) 165 + static int xts_encrypt(struct skcipher_request *req) 176 166 { 177 - struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 167 + struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 168 + struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm); 178 169 179 - return glue_xts_crypt_128bit(&serpent_enc_xts, desc, dst, src, nbytes, 180 - XTS_TWEAK_CAST(__serpent_encrypt), 181 - &ctx->tweak_ctx, &ctx->crypt_ctx); 170 + return glue_xts_req_128bit(&serpent_enc_xts, req, 171 + XTS_TWEAK_CAST(__serpent_encrypt), 172 + &ctx->tweak_ctx, &ctx->crypt_ctx); 182 173 } 183 174 184 - static int xts_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 185 - struct scatterlist *src, unsigned int nbytes) 175 + static int xts_decrypt(struct skcipher_request *req) 186 176 { 187 - struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 177 + struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 178 + struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm); 188 179 189 - return glue_xts_crypt_128bit(&serpent_dec_xts, desc, dst, src, nbytes, 190 - XTS_TWEAK_CAST(__serpent_encrypt), 191 - &ctx->tweak_ctx, &ctx->crypt_ctx); 180 + return glue_xts_req_128bit(&serpent_dec_xts, req, 181 + XTS_TWEAK_CAST(__serpent_encrypt), 182 + &ctx->tweak_ctx, &ctx->crypt_ctx); 192 183 } 193 184 194 - static struct crypto_alg srp_algs[] = { { 195 - .cra_name = "__ecb-serpent-avx2", 196 - .cra_driver_name = "__driver-ecb-serpent-avx2", 197 - .cra_priority = 0, 198 - .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 199 - CRYPTO_ALG_INTERNAL, 200 - .cra_blocksize = SERPENT_BLOCK_SIZE, 201 - .cra_ctxsize = sizeof(struct serpent_ctx), 202 - .cra_alignmask = 0, 203 - .cra_type = &crypto_blkcipher_type, 204 - .cra_module = THIS_MODULE, 205 - .cra_u = { 206 - .blkcipher = { 207 - .min_keysize = SERPENT_MIN_KEY_SIZE, 208 - .max_keysize = SERPENT_MAX_KEY_SIZE, 209 - .setkey = serpent_setkey, 210 - .encrypt = ecb_encrypt, 211 - .decrypt = ecb_decrypt, 212 - }, 185 + static struct skcipher_alg serpent_algs[] = { 186 + { 187 + .base.cra_name = "__ecb(serpent)", 188 + .base.cra_driver_name = "__ecb-serpent-avx2", 189 + .base.cra_priority = 600, 190 + .base.cra_flags = CRYPTO_ALG_INTERNAL, 191 + .base.cra_blocksize = SERPENT_BLOCK_SIZE, 192 + .base.cra_ctxsize = sizeof(struct serpent_ctx), 193 + .base.cra_module = THIS_MODULE, 194 + .min_keysize = SERPENT_MIN_KEY_SIZE, 195 + .max_keysize = SERPENT_MAX_KEY_SIZE, 196 + .setkey = serpent_setkey_skcipher, 197 + .encrypt = ecb_encrypt, 198 + .decrypt = ecb_decrypt, 199 + }, { 200 + .base.cra_name = "__cbc(serpent)", 201 + .base.cra_driver_name = "__cbc-serpent-avx2", 202 + .base.cra_priority = 600, 203 + .base.cra_flags = CRYPTO_ALG_INTERNAL, 204 + .base.cra_blocksize = SERPENT_BLOCK_SIZE, 205 + .base.cra_ctxsize = sizeof(struct serpent_ctx), 206 + .base.cra_module = THIS_MODULE, 207 + .min_keysize = SERPENT_MIN_KEY_SIZE, 208 + .max_keysize = SERPENT_MAX_KEY_SIZE, 209 + .ivsize = SERPENT_BLOCK_SIZE, 210 + .setkey = serpent_setkey_skcipher, 211 + .encrypt = cbc_encrypt, 212 + .decrypt = cbc_decrypt, 213 + }, { 214 + .base.cra_name = "__ctr(serpent)", 215 + .base.cra_driver_name = "__ctr-serpent-avx2", 216 + .base.cra_priority = 600, 217 + .base.cra_flags = CRYPTO_ALG_INTERNAL, 218 + .base.cra_blocksize = 1, 219 + .base.cra_ctxsize = sizeof(struct serpent_ctx), 220 + .base.cra_module = THIS_MODULE, 221 + .min_keysize = SERPENT_MIN_KEY_SIZE, 222 + .max_keysize = SERPENT_MAX_KEY_SIZE, 223 + .ivsize = SERPENT_BLOCK_SIZE, 224 + .chunksize = SERPENT_BLOCK_SIZE, 225 + .setkey = serpent_setkey_skcipher, 226 + .encrypt = ctr_crypt, 227 + .decrypt = ctr_crypt, 228 + }, { 229 + .base.cra_name = "__xts(serpent)", 230 + .base.cra_driver_name = "__xts-serpent-avx2", 231 + .base.cra_priority = 600, 232 + .base.cra_flags = CRYPTO_ALG_INTERNAL, 233 + .base.cra_blocksize = SERPENT_BLOCK_SIZE, 234 + .base.cra_ctxsize = sizeof(struct serpent_xts_ctx), 235 + .base.cra_module = THIS_MODULE, 236 + .min_keysize = 2 * SERPENT_MIN_KEY_SIZE, 237 + .max_keysize = 2 * SERPENT_MAX_KEY_SIZE, 238 + .ivsize = SERPENT_BLOCK_SIZE, 239 + .setkey = xts_serpent_setkey, 240 + .encrypt = xts_encrypt, 241 + .decrypt = xts_decrypt, 213 242 }, 214 - }, { 215 - .cra_name = "__cbc-serpent-avx2", 216 - .cra_driver_name = "__driver-cbc-serpent-avx2", 217 - .cra_priority = 0, 218 - .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 219 - CRYPTO_ALG_INTERNAL, 220 - .cra_blocksize = SERPENT_BLOCK_SIZE, 221 - .cra_ctxsize = sizeof(struct serpent_ctx), 222 - .cra_alignmask = 0, 223 - .cra_type = &crypto_blkcipher_type, 224 - .cra_module = THIS_MODULE, 225 - .cra_u = { 226 - .blkcipher = { 227 - .min_keysize = SERPENT_MIN_KEY_SIZE, 228 - .max_keysize = SERPENT_MAX_KEY_SIZE, 229 - .setkey = serpent_setkey, 230 - .encrypt = cbc_encrypt, 231 - .decrypt = cbc_decrypt, 232 - }, 233 - }, 234 - }, { 235 - .cra_name = "__ctr-serpent-avx2", 236 - .cra_driver_name = "__driver-ctr-serpent-avx2", 237 - .cra_priority = 0, 238 - .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 239 - CRYPTO_ALG_INTERNAL, 240 - .cra_blocksize = 1, 241 - .cra_ctxsize = sizeof(struct serpent_ctx), 242 - .cra_alignmask = 0, 243 - .cra_type = &crypto_blkcipher_type, 244 - .cra_module = THIS_MODULE, 245 - .cra_u = { 246 - .blkcipher = { 247 - .min_keysize = SERPENT_MIN_KEY_SIZE, 248 - .max_keysize = SERPENT_MAX_KEY_SIZE, 249 - .ivsize = SERPENT_BLOCK_SIZE, 250 - .setkey = serpent_setkey, 251 - .encrypt = ctr_crypt, 252 - .decrypt = ctr_crypt, 253 - }, 254 - }, 255 - }, { 256 - .cra_name = "__xts-serpent-avx2", 257 - .cra_driver_name = "__driver-xts-serpent-avx2", 258 - .cra_priority = 0, 259 - .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 260 - CRYPTO_ALG_INTERNAL, 261 - .cra_blocksize = SERPENT_BLOCK_SIZE, 262 - .cra_ctxsize = sizeof(struct serpent_xts_ctx), 263 - .cra_alignmask = 0, 264 - .cra_type = &crypto_blkcipher_type, 265 - .cra_module = THIS_MODULE, 266 - .cra_u = { 267 - .blkcipher = { 268 - .min_keysize = SERPENT_MIN_KEY_SIZE * 2, 269 - .max_keysize = SERPENT_MAX_KEY_SIZE * 2, 270 - .ivsize = SERPENT_BLOCK_SIZE, 271 - .setkey = xts_serpent_setkey, 272 - .encrypt = xts_encrypt, 273 - .decrypt = xts_decrypt, 274 - }, 275 - }, 276 - }, { 277 - .cra_name = "ecb(serpent)", 278 - .cra_driver_name = "ecb-serpent-avx2", 279 - .cra_priority = 600, 280 - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 281 - .cra_blocksize = SERPENT_BLOCK_SIZE, 282 - .cra_ctxsize = sizeof(struct async_helper_ctx), 283 - .cra_alignmask = 0, 284 - .cra_type = &crypto_ablkcipher_type, 285 - .cra_module = THIS_MODULE, 286 - .cra_init = ablk_init, 287 - .cra_exit = ablk_exit, 288 - .cra_u = { 289 - .ablkcipher = { 290 - .min_keysize = SERPENT_MIN_KEY_SIZE, 291 - .max_keysize = SERPENT_MAX_KEY_SIZE, 292 - .setkey = ablk_set_key, 293 - .encrypt = ablk_encrypt, 294 - .decrypt = ablk_decrypt, 295 - }, 296 - }, 297 - }, { 298 - .cra_name = "cbc(serpent)", 299 - .cra_driver_name = "cbc-serpent-avx2", 300 - .cra_priority = 600, 301 - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 302 - .cra_blocksize = SERPENT_BLOCK_SIZE, 303 - .cra_ctxsize = sizeof(struct async_helper_ctx), 304 - .cra_alignmask = 0, 305 - .cra_type = &crypto_ablkcipher_type, 306 - .cra_module = THIS_MODULE, 307 - .cra_init = ablk_init, 308 - .cra_exit = ablk_exit, 309 - .cra_u = { 310 - .ablkcipher = { 311 - .min_keysize = SERPENT_MIN_KEY_SIZE, 312 - .max_keysize = SERPENT_MAX_KEY_SIZE, 313 - .ivsize = SERPENT_BLOCK_SIZE, 314 - .setkey = ablk_set_key, 315 - .encrypt = __ablk_encrypt, 316 - .decrypt = ablk_decrypt, 317 - }, 318 - }, 319 - }, { 320 - .cra_name = "ctr(serpent)", 321 - .cra_driver_name = "ctr-serpent-avx2", 322 - .cra_priority = 600, 323 - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 324 - .cra_blocksize = 1, 325 - .cra_ctxsize = sizeof(struct async_helper_ctx), 326 - .cra_alignmask = 0, 327 - .cra_type = &crypto_ablkcipher_type, 328 - .cra_module = THIS_MODULE, 329 - .cra_init = ablk_init, 330 - .cra_exit = ablk_exit, 331 - .cra_u = { 332 - .ablkcipher = { 333 - .min_keysize = SERPENT_MIN_KEY_SIZE, 334 - .max_keysize = SERPENT_MAX_KEY_SIZE, 335 - .ivsize = SERPENT_BLOCK_SIZE, 336 - .setkey = ablk_set_key, 337 - .encrypt = ablk_encrypt, 338 - .decrypt = ablk_encrypt, 339 - .geniv = "chainiv", 340 - }, 341 - }, 342 - }, { 343 - .cra_name = "xts(serpent)", 344 - .cra_driver_name = "xts-serpent-avx2", 345 - .cra_priority = 600, 346 - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 347 - .cra_blocksize = SERPENT_BLOCK_SIZE, 348 - .cra_ctxsize = sizeof(struct async_helper_ctx), 349 - .cra_alignmask = 0, 350 - .cra_type = &crypto_ablkcipher_type, 351 - .cra_module = THIS_MODULE, 352 - .cra_init = ablk_init, 353 - .cra_exit = ablk_exit, 354 - .cra_u = { 355 - .ablkcipher = { 356 - .min_keysize = SERPENT_MIN_KEY_SIZE * 2, 357 - .max_keysize = SERPENT_MAX_KEY_SIZE * 2, 358 - .ivsize = SERPENT_BLOCK_SIZE, 359 - .setkey = ablk_set_key, 360 - .encrypt = ablk_encrypt, 361 - .decrypt = ablk_decrypt, 362 - }, 363 - }, 364 - } }; 243 + }; 244 + 245 + static struct simd_skcipher_alg *serpent_simd_algs[ARRAY_SIZE(serpent_algs)]; 365 246 366 247 static int __init init(void) 367 248 { ··· 261 374 return -ENODEV; 262 375 } 263 376 264 - return crypto_register_algs(srp_algs, ARRAY_SIZE(srp_algs)); 377 + return simd_register_skciphers_compat(serpent_algs, 378 + ARRAY_SIZE(serpent_algs), 379 + serpent_simd_algs); 265 380 } 266 381 267 382 static void __exit fini(void) 268 383 { 269 - crypto_unregister_algs(srp_algs, ARRAY_SIZE(srp_algs)); 384 + simd_unregister_skciphers(serpent_algs, ARRAY_SIZE(serpent_algs), 385 + serpent_simd_algs); 270 386 } 271 387 272 388 module_init(init);

+115 -228

arch/x86/crypto/serpent_avx_glue.c

··· 24 24 */ 25 25 26 26 #include <linux/module.h> 27 - #include <linux/hardirq.h> 28 27 #include <linux/types.h> 29 28 #include <linux/crypto.h> 30 29 #include <linux/err.h> 31 - #include <crypto/ablk_helper.h> 32 30 #include <crypto/algapi.h> 31 + #include <crypto/internal/simd.h> 33 32 #include <crypto/serpent.h> 34 - #include <crypto/cryptd.h> 35 - #include <crypto/b128ops.h> 36 - #include <crypto/ctr.h> 37 33 #include <crypto/xts.h> 38 - #include <asm/fpu/api.h> 39 - #include <asm/crypto/serpent-avx.h> 40 34 #include <asm/crypto/glue_helper.h> 35 + #include <asm/crypto/serpent-avx.h> 41 36 42 37 /* 8-way parallel cipher functions */ 43 38 asmlinkage void serpent_ecb_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst, ··· 85 90 } 86 91 EXPORT_SYMBOL_GPL(serpent_xts_dec); 87 92 93 + static int serpent_setkey_skcipher(struct crypto_skcipher *tfm, 94 + const u8 *key, unsigned int keylen) 95 + { 96 + return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen); 97 + } 98 + 99 + int xts_serpent_setkey(struct crypto_skcipher *tfm, const u8 *key, 100 + unsigned int keylen) 101 + { 102 + struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm); 103 + int err; 104 + 105 + err = xts_verify_key(tfm, key, keylen); 106 + if (err) 107 + return err; 108 + 109 + /* first half of xts-key is for crypt */ 110 + err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2); 111 + if (err) 112 + return err; 113 + 114 + /* second half of xts-key is for tweak */ 115 + return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2); 116 + } 117 + EXPORT_SYMBOL_GPL(xts_serpent_setkey); 88 118 89 119 static const struct common_glue_ctx serpent_enc = { 90 120 .num_funcs = 2, ··· 189 169 } } 190 170 }; 191 171 192 - static int ecb_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 193 - struct scatterlist *src, unsigned int nbytes) 172 + static int ecb_encrypt(struct skcipher_request *req) 194 173 { 195 - return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes); 174 + return glue_ecb_req_128bit(&serpent_enc, req); 196 175 } 197 176 198 - static int ecb_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 199 - struct scatterlist *src, unsigned int nbytes) 177 + static int ecb_decrypt(struct skcipher_request *req) 200 178 { 201 - return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes); 179 + return glue_ecb_req_128bit(&serpent_dec, req); 202 180 } 203 181 204 - static int cbc_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 205 - struct scatterlist *src, unsigned int nbytes) 182 + static int cbc_encrypt(struct skcipher_request *req) 206 183 { 207 - return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc, 208 - dst, src, nbytes); 184 + return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__serpent_encrypt), 185 + req); 209 186 } 210 187 211 - static int cbc_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 212 - struct scatterlist *src, unsigned int nbytes) 188 + static int cbc_decrypt(struct skcipher_request *req) 213 189 { 214 - return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src, 215 - nbytes); 190 + return glue_cbc_decrypt_req_128bit(&serpent_dec_cbc, req); 216 191 } 217 192 218 - static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst, 219 - struct scatterlist *src, unsigned int nbytes) 193 + static int ctr_crypt(struct skcipher_request *req) 220 194 { 221 - return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes); 195 + return glue_ctr_req_128bit(&serpent_ctr, req); 222 196 } 223 197 224 - int xts_serpent_setkey(struct crypto_tfm *tfm, const u8 *key, 225 - unsigned int keylen) 198 + static int xts_encrypt(struct skcipher_request *req) 226 199 { 227 - struct serpent_xts_ctx *ctx = crypto_tfm_ctx(tfm); 228 - int err; 200 + struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 201 + struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm); 229 202 230 - err = xts_check_key(tfm, key, keylen); 231 - if (err) 232 - return err; 233 - 234 - /* first half of xts-key is for crypt */ 235 - err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2); 236 - if (err) 237 - return err; 238 - 239 - /* second half of xts-key is for tweak */ 240 - return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2); 241 - } 242 - EXPORT_SYMBOL_GPL(xts_serpent_setkey); 243 - 244 - static int xts_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 245 - struct scatterlist *src, unsigned int nbytes) 246 - { 247 - struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 248 - 249 - return glue_xts_crypt_128bit(&serpent_enc_xts, desc, dst, src, nbytes, 250 - XTS_TWEAK_CAST(__serpent_encrypt), 251 - &ctx->tweak_ctx, &ctx->crypt_ctx); 203 + return glue_xts_req_128bit(&serpent_enc_xts, req, 204 + XTS_TWEAK_CAST(__serpent_encrypt), 205 + &ctx->tweak_ctx, &ctx->crypt_ctx); 252 206 } 253 207 254 - static int xts_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 255 - struct scatterlist *src, unsigned int nbytes) 208 + static int xts_decrypt(struct skcipher_request *req) 256 209 { 257 - struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 210 + struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 211 + struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm); 258 212 259 - return glue_xts_crypt_128bit(&serpent_dec_xts, desc, dst, src, nbytes, 260 - XTS_TWEAK_CAST(__serpent_encrypt), 261 - &ctx->tweak_ctx, &ctx->crypt_ctx); 213 + return glue_xts_req_128bit(&serpent_dec_xts, req, 214 + XTS_TWEAK_CAST(__serpent_encrypt), 215 + &ctx->tweak_ctx, &ctx->crypt_ctx); 262 216 } 263 217 264 - static struct crypto_alg serpent_algs[] = { { 265 - .cra_name = "__ecb-serpent-avx", 266 - .cra_driver_name = "__driver-ecb-serpent-avx", 267 - .cra_priority = 0, 268 - .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 269 - CRYPTO_ALG_INTERNAL, 270 - .cra_blocksize = SERPENT_BLOCK_SIZE, 271 - .cra_ctxsize = sizeof(struct serpent_ctx), 272 - .cra_alignmask = 0, 273 - .cra_type = &crypto_blkcipher_type, 274 - .cra_module = THIS_MODULE, 275 - .cra_u = { 276 - .blkcipher = { 277 - .min_keysize = SERPENT_MIN_KEY_SIZE, 278 - .max_keysize = SERPENT_MAX_KEY_SIZE, 279 - .setkey = serpent_setkey, 280 - .encrypt = ecb_encrypt, 281 - .decrypt = ecb_decrypt, 282 - }, 218 + static struct skcipher_alg serpent_algs[] = { 219 + { 220 + .base.cra_name = "__ecb(serpent)", 221 + .base.cra_driver_name = "__ecb-serpent-avx", 222 + .base.cra_priority = 500, 223 + .base.cra_flags = CRYPTO_ALG_INTERNAL, 224 + .base.cra_blocksize = SERPENT_BLOCK_SIZE, 225 + .base.cra_ctxsize = sizeof(struct serpent_ctx), 226 + .base.cra_module = THIS_MODULE, 227 + .min_keysize = SERPENT_MIN_KEY_SIZE, 228 + .max_keysize = SERPENT_MAX_KEY_SIZE, 229 + .setkey = serpent_setkey_skcipher, 230 + .encrypt = ecb_encrypt, 231 + .decrypt = ecb_decrypt, 232 + }, { 233 + .base.cra_name = "__cbc(serpent)", 234 + .base.cra_driver_name = "__cbc-serpent-avx", 235 + .base.cra_priority = 500, 236 + .base.cra_flags = CRYPTO_ALG_INTERNAL, 237 + .base.cra_blocksize = SERPENT_BLOCK_SIZE, 238 + .base.cra_ctxsize = sizeof(struct serpent_ctx), 239 + .base.cra_module = THIS_MODULE, 240 + .min_keysize = SERPENT_MIN_KEY_SIZE, 241 + .max_keysize = SERPENT_MAX_KEY_SIZE, 242 + .ivsize = SERPENT_BLOCK_SIZE, 243 + .setkey = serpent_setkey_skcipher, 244 + .encrypt = cbc_encrypt, 245 + .decrypt = cbc_decrypt, 246 + }, { 247 + .base.cra_name = "__ctr(serpent)", 248 + .base.cra_driver_name = "__ctr-serpent-avx", 249 + .base.cra_priority = 500, 250 + .base.cra_flags = CRYPTO_ALG_INTERNAL, 251 + .base.cra_blocksize = 1, 252 + .base.cra_ctxsize = sizeof(struct serpent_ctx), 253 + .base.cra_module = THIS_MODULE, 254 + .min_keysize = SERPENT_MIN_KEY_SIZE, 255 + .max_keysize = SERPENT_MAX_KEY_SIZE, 256 + .ivsize = SERPENT_BLOCK_SIZE, 257 + .chunksize = SERPENT_BLOCK_SIZE, 258 + .setkey = serpent_setkey_skcipher, 259 + .encrypt = ctr_crypt, 260 + .decrypt = ctr_crypt, 261 + }, { 262 + .base.cra_name = "__xts(serpent)", 263 + .base.cra_driver_name = "__xts-serpent-avx", 264 + .base.cra_priority = 500, 265 + .base.cra_flags = CRYPTO_ALG_INTERNAL, 266 + .base.cra_blocksize = SERPENT_BLOCK_SIZE, 267 + .base.cra_ctxsize = sizeof(struct serpent_xts_ctx), 268 + .base.cra_module = THIS_MODULE, 269 + .min_keysize = 2 * SERPENT_MIN_KEY_SIZE, 270 + .max_keysize = 2 * SERPENT_MAX_KEY_SIZE, 271 + .ivsize = SERPENT_BLOCK_SIZE, 272 + .setkey = xts_serpent_setkey, 273 + .encrypt = xts_encrypt, 274 + .decrypt = xts_decrypt, 283 275 }, 284 - }, { 285 - .cra_name = "__cbc-serpent-avx", 286 - .cra_driver_name = "__driver-cbc-serpent-avx", 287 - .cra_priority = 0, 288 - .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 289 - CRYPTO_ALG_INTERNAL, 290 - .cra_blocksize = SERPENT_BLOCK_SIZE, 291 - .cra_ctxsize = sizeof(struct serpent_ctx), 292 - .cra_alignmask = 0, 293 - .cra_type = &crypto_blkcipher_type, 294 - .cra_module = THIS_MODULE, 295 - .cra_u = { 296 - .blkcipher = { 297 - .min_keysize = SERPENT_MIN_KEY_SIZE, 298 - .max_keysize = SERPENT_MAX_KEY_SIZE, 299 - .setkey = serpent_setkey, 300 - .encrypt = cbc_encrypt, 301 - .decrypt = cbc_decrypt, 302 - }, 303 - }, 304 - }, { 305 - .cra_name = "__ctr-serpent-avx", 306 - .cra_driver_name = "__driver-ctr-serpent-avx", 307 - .cra_priority = 0, 308 - .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 309 - CRYPTO_ALG_INTERNAL, 310 - .cra_blocksize = 1, 311 - .cra_ctxsize = sizeof(struct serpent_ctx), 312 - .cra_alignmask = 0, 313 - .cra_type = &crypto_blkcipher_type, 314 - .cra_module = THIS_MODULE, 315 - .cra_u = { 316 - .blkcipher = { 317 - .min_keysize = SERPENT_MIN_KEY_SIZE, 318 - .max_keysize = SERPENT_MAX_KEY_SIZE, 319 - .ivsize = SERPENT_BLOCK_SIZE, 320 - .setkey = serpent_setkey, 321 - .encrypt = ctr_crypt, 322 - .decrypt = ctr_crypt, 323 - }, 324 - }, 325 - }, { 326 - .cra_name = "__xts-serpent-avx", 327 - .cra_driver_name = "__driver-xts-serpent-avx", 328 - .cra_priority = 0, 329 - .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 330 - CRYPTO_ALG_INTERNAL, 331 - .cra_blocksize = SERPENT_BLOCK_SIZE, 332 - .cra_ctxsize = sizeof(struct serpent_xts_ctx), 333 - .cra_alignmask = 0, 334 - .cra_type = &crypto_blkcipher_type, 335 - .cra_module = THIS_MODULE, 336 - .cra_u = { 337 - .blkcipher = { 338 - .min_keysize = SERPENT_MIN_KEY_SIZE * 2, 339 - .max_keysize = SERPENT_MAX_KEY_SIZE * 2, 340 - .ivsize = SERPENT_BLOCK_SIZE, 341 - .setkey = xts_serpent_setkey, 342 - .encrypt = xts_encrypt, 343 - .decrypt = xts_decrypt, 344 - }, 345 - }, 346 - }, { 347 - .cra_name = "ecb(serpent)", 348 - .cra_driver_name = "ecb-serpent-avx", 349 - .cra_priority = 500, 350 - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 351 - .cra_blocksize = SERPENT_BLOCK_SIZE, 352 - .cra_ctxsize = sizeof(struct async_helper_ctx), 353 - .cra_alignmask = 0, 354 - .cra_type = &crypto_ablkcipher_type, 355 - .cra_module = THIS_MODULE, 356 - .cra_init = ablk_init, 357 - .cra_exit = ablk_exit, 358 - .cra_u = { 359 - .ablkcipher = { 360 - .min_keysize = SERPENT_MIN_KEY_SIZE, 361 - .max_keysize = SERPENT_MAX_KEY_SIZE, 362 - .setkey = ablk_set_key, 363 - .encrypt = ablk_encrypt, 364 - .decrypt = ablk_decrypt, 365 - }, 366 - }, 367 - }, { 368 - .cra_name = "cbc(serpent)", 369 - .cra_driver_name = "cbc-serpent-avx", 370 - .cra_priority = 500, 371 - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 372 - .cra_blocksize = SERPENT_BLOCK_SIZE, 373 - .cra_ctxsize = sizeof(struct async_helper_ctx), 374 - .cra_alignmask = 0, 375 - .cra_type = &crypto_ablkcipher_type, 376 - .cra_module = THIS_MODULE, 377 - .cra_init = ablk_init, 378 - .cra_exit = ablk_exit, 379 - .cra_u = { 380 - .ablkcipher = { 381 - .min_keysize = SERPENT_MIN_KEY_SIZE, 382 - .max_keysize = SERPENT_MAX_KEY_SIZE, 383 - .ivsize = SERPENT_BLOCK_SIZE, 384 - .setkey = ablk_set_key, 385 - .encrypt = __ablk_encrypt, 386 - .decrypt = ablk_decrypt, 387 - }, 388 - }, 389 - }, { 390 - .cra_name = "ctr(serpent)", 391 - .cra_driver_name = "ctr-serpent-avx", 392 - .cra_priority = 500, 393 - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 394 - .cra_blocksize = 1, 395 - .cra_ctxsize = sizeof(struct async_helper_ctx), 396 - .cra_alignmask = 0, 397 - .cra_type = &crypto_ablkcipher_type, 398 - .cra_module = THIS_MODULE, 399 - .cra_init = ablk_init, 400 - .cra_exit = ablk_exit, 401 - .cra_u = { 402 - .ablkcipher = { 403 - .min_keysize = SERPENT_MIN_KEY_SIZE, 404 - .max_keysize = SERPENT_MAX_KEY_SIZE, 405 - .ivsize = SERPENT_BLOCK_SIZE, 406 - .setkey = ablk_set_key, 407 - .encrypt = ablk_encrypt, 408 - .decrypt = ablk_encrypt, 409 - .geniv = "chainiv", 410 - }, 411 - }, 412 - }, { 413 - .cra_name = "xts(serpent)", 414 - .cra_driver_name = "xts-serpent-avx", 415 - .cra_priority = 500, 416 - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 417 - .cra_blocksize = SERPENT_BLOCK_SIZE, 418 - .cra_ctxsize = sizeof(struct async_helper_ctx), 419 - .cra_alignmask = 0, 420 - .cra_type = &crypto_ablkcipher_type, 421 - .cra_module = THIS_MODULE, 422 - .cra_init = ablk_init, 423 - .cra_exit = ablk_exit, 424 - .cra_u = { 425 - .ablkcipher = { 426 - .min_keysize = SERPENT_MIN_KEY_SIZE * 2, 427 - .max_keysize = SERPENT_MAX_KEY_SIZE * 2, 428 - .ivsize = SERPENT_BLOCK_SIZE, 429 - .setkey = ablk_set_key, 430 - .encrypt = ablk_encrypt, 431 - .decrypt = ablk_decrypt, 432 - }, 433 - }, 434 - } }; 276 + }; 277 + 278 + static struct simd_skcipher_alg *serpent_simd_algs[ARRAY_SIZE(serpent_algs)]; 435 279 436 280 static int __init serpent_init(void) 437 281 { ··· 307 423 return -ENODEV; 308 424 } 309 425 310 - return crypto_register_algs(serpent_algs, ARRAY_SIZE(serpent_algs)); 426 + return simd_register_skciphers_compat(serpent_algs, 427 + ARRAY_SIZE(serpent_algs), 428 + serpent_simd_algs); 311 429 } 312 430 313 431 static void __exit serpent_exit(void) 314 432 { 315 - crypto_unregister_algs(serpent_algs, ARRAY_SIZE(serpent_algs)); 433 + simd_unregister_skciphers(serpent_algs, ARRAY_SIZE(serpent_algs), 434 + serpent_simd_algs); 316 435 } 317 436 318 437 module_init(serpent_init);

+5 -2

arch/x86/include/asm/crypto/serpent-avx.h

··· 2 2 #ifndef ASM_X86_SERPENT_AVX_H 3 3 #define ASM_X86_SERPENT_AVX_H 4 4 5 - #include <linux/crypto.h> 5 + #include <crypto/b128ops.h> 6 6 #include <crypto/serpent.h> 7 + #include <linux/types.h> 8 + 9 + struct crypto_skcipher; 7 10 8 11 #define SERPENT_PARALLEL_BLOCKS 8 9 12 ··· 36 33 extern void serpent_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv); 37 34 extern void serpent_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv); 38 35 39 - extern int xts_serpent_setkey(struct crypto_tfm *tfm, const u8 *key, 36 + extern int xts_serpent_setkey(struct crypto_skcipher *tfm, const u8 *key, 40 37 unsigned int keylen); 41 38 42 39 #endif

+2 -9

crypto/Kconfig

··· 1460 1460 config CRYPTO_SERPENT_AVX_X86_64 1461 1461 tristate "Serpent cipher algorithm (x86_64/AVX)" 1462 1462 depends on X86 && 64BIT 1463 - select CRYPTO_ALGAPI 1464 - select CRYPTO_CRYPTD 1465 - select CRYPTO_ABLK_HELPER 1463 + select CRYPTO_BLKCIPHER 1466 1464 select CRYPTO_GLUE_HELPER_X86 1467 1465 select CRYPTO_SERPENT 1466 + select CRYPTO_SIMD 1468 1467 select CRYPTO_XTS 1469 1468 help 1470 1469 Serpent cipher algorithm, by Anderson, Biham & Knudsen. ··· 1480 1481 config CRYPTO_SERPENT_AVX2_X86_64 1481 1482 tristate "Serpent cipher algorithm (x86_64/AVX2)" 1482 1483 depends on X86 && 64BIT 1483 - select CRYPTO_ALGAPI 1484 - select CRYPTO_CRYPTD 1485 - select CRYPTO_ABLK_HELPER 1486 - select CRYPTO_GLUE_HELPER_X86 1487 - select CRYPTO_SERPENT 1488 1484 select CRYPTO_SERPENT_AVX_X86_64 1489 - select CRYPTO_XTS 1490 1485 help 1491 1486 Serpent cipher algorithm, by Anderson, Biham & Knudsen. 1492 1487