1 /* 2 * Glue Code for SSE2 assembler versions of Serpent Cipher 3 * 4 * Copyright (c) 2011 Jussi Kivilinna <jussi.kivilinna@mbnet.fi> 5 * 6 * Glue code based on aesni-intel_glue.c by: 7 * Copyright (C) 2008, Intel Corp. 8 * Author: Huang Ying <ying.huang@intel.com> 9 * 10 * CBC & ECB parts based on code (crypto/cbc.c,ecb.c) by: 11 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> 12 * CTR part based on code (crypto/ctr.c) by: 13 * (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com> 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of the GNU General Public License as published by 17 * the Free Software Foundation; either version 2 of the License, or 18 * (at your option) any later version. 19 * 20 * This program is distributed in the hope that it will be useful, 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 * GNU General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public License 26 * along with this program; if not, write to the Free Software 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 28 * USA 29 * 30 */ 31 32 #include <linux/module.h> 33 #include <linux/hardirq.h> 34 #include <linux/types.h> 35 #include <linux/crypto.h> 36 #include <linux/err.h> 37 #include <crypto/ablk_helper.h> 38 #include <crypto/algapi.h> 39 #include <crypto/serpent.h> 40 #include <crypto/cryptd.h> 41 #include <crypto/b128ops.h> 42 #include <crypto/ctr.h> 43 #include <crypto/lrw.h> 44 #include <crypto/xts.h> 45 #include <asm/crypto/serpent-sse2.h> 46 #include <asm/crypto/glue_helper.h> 47 48 static void serpent_decrypt_cbc_xway(void *ctx, u128 *dst, const u128 *src) 49 { 50 u128 ivs[SERPENT_PARALLEL_BLOCKS - 1]; 51 unsigned int j; 52 53 for (j = 0; j < SERPENT_PARALLEL_BLOCKS - 1; j++) 54 ivs[j] = src[j]; 55 56 serpent_dec_blk_xway(ctx, (u8 *)dst, (u8 *)src); 57 58 for (j = 0; j < SERPENT_PARALLEL_BLOCKS - 1; j++) 59 u128_xor(dst + (j + 1), dst + (j + 1), ivs + j); 60 } 61 62 static void serpent_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv) 63 { 64 be128 ctrblk; 65 66 le128_to_be128(&ctrblk, iv); 67 le128_inc(iv); 68 69 __serpent_encrypt(ctx, (u8 *)&ctrblk, (u8 *)&ctrblk); 70 u128_xor(dst, src, (u128 *)&ctrblk); 71 } 72 73 static void serpent_crypt_ctr_xway(void *ctx, u128 *dst, const u128 *src, 74 le128 *iv) 75 { 76 be128 ctrblks[SERPENT_PARALLEL_BLOCKS]; 77 unsigned int i; 78 79 for (i = 0; i < SERPENT_PARALLEL_BLOCKS; i++) { 80 if (dst != src) 81 dst[i] = src[i]; 82 83 le128_to_be128(&ctrblks[i], iv); 84 le128_inc(iv); 85 } 86 87 serpent_enc_blk_xway_xor(ctx, (u8 *)dst, (u8 *)ctrblks); 88 } 89 90 static const struct common_glue_ctx serpent_enc = { 91 .num_funcs = 2, 92 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, 93 94 .funcs = { { 95 .num_blocks = SERPENT_PARALLEL_BLOCKS, 96 .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_enc_blk_xway) } 97 }, { 98 .num_blocks = 1, 99 .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) } 100 } } 101 }; 102 103 static const struct common_glue_ctx serpent_ctr = { 104 .num_funcs = 2, 105 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, 106 107 .funcs = { { 108 .num_blocks = SERPENT_PARALLEL_BLOCKS, 109 .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_crypt_ctr_xway) } 110 }, { 111 .num_blocks = 1, 112 .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_crypt_ctr) } 113 } } 114 }; 115 116 static const struct common_glue_ctx serpent_dec = { 117 .num_funcs = 2, 118 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, 119 120 .funcs = { { 121 .num_blocks = SERPENT_PARALLEL_BLOCKS, 122 .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_dec_blk_xway) } 123 }, { 124 .num_blocks = 1, 125 .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) } 126 } } 127 }; 128 129 static const struct common_glue_ctx serpent_dec_cbc = { 130 .num_funcs = 2, 131 .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, 132 133 .funcs = { { 134 .num_blocks = SERPENT_PARALLEL_BLOCKS, 135 .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_decrypt_cbc_xway) } 136 }, { 137 .num_blocks = 1, 138 .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) } 139 } } 140 }; 141 142 static int ecb_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 143 struct scatterlist *src, unsigned int nbytes) 144 { 145 return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes); 146 } 147 148 static int ecb_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 149 struct scatterlist *src, unsigned int nbytes) 150 { 151 return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes); 152 } 153 154 static int cbc_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 155 struct scatterlist *src, unsigned int nbytes) 156 { 157 return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc, 158 dst, src, nbytes); 159 } 160 161 static int cbc_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 162 struct scatterlist *src, unsigned int nbytes) 163 { 164 return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src, 165 nbytes); 166 } 167 168 static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst, 169 struct scatterlist *src, unsigned int nbytes) 170 { 171 return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes); 172 } 173 174 static inline bool serpent_fpu_begin(bool fpu_enabled, unsigned int nbytes) 175 { 176 return glue_fpu_begin(SERPENT_BLOCK_SIZE, SERPENT_PARALLEL_BLOCKS, 177 NULL, fpu_enabled, nbytes); 178 } 179 180 static inline void serpent_fpu_end(bool fpu_enabled) 181 { 182 glue_fpu_end(fpu_enabled); 183 } 184 185 struct crypt_priv { 186 struct serpent_ctx *ctx; 187 bool fpu_enabled; 188 }; 189 190 static void encrypt_callback(void *priv, u8 *srcdst, unsigned int nbytes) 191 { 192 const unsigned int bsize = SERPENT_BLOCK_SIZE; 193 struct crypt_priv *ctx = priv; 194 int i; 195 196 ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes); 197 198 if (nbytes == bsize * SERPENT_PARALLEL_BLOCKS) { 199 serpent_enc_blk_xway(ctx->ctx, srcdst, srcdst); 200 return; 201 } 202 203 for (i = 0; i < nbytes / bsize; i++, srcdst += bsize) 204 __serpent_encrypt(ctx->ctx, srcdst, srcdst); 205 } 206 207 static void decrypt_callback(void *priv, u8 *srcdst, unsigned int nbytes) 208 { 209 const unsigned int bsize = SERPENT_BLOCK_SIZE; 210 struct crypt_priv *ctx = priv; 211 int i; 212 213 ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes); 214 215 if (nbytes == bsize * SERPENT_PARALLEL_BLOCKS) { 216 serpent_dec_blk_xway(ctx->ctx, srcdst, srcdst); 217 return; 218 } 219 220 for (i = 0; i < nbytes / bsize; i++, srcdst += bsize) 221 __serpent_decrypt(ctx->ctx, srcdst, srcdst); 222 } 223 224 struct serpent_lrw_ctx { 225 struct lrw_table_ctx lrw_table; 226 struct serpent_ctx serpent_ctx; 227 }; 228 229 static int lrw_serpent_setkey(struct crypto_tfm *tfm, const u8 *key, 230 unsigned int keylen) 231 { 232 struct serpent_lrw_ctx *ctx = crypto_tfm_ctx(tfm); 233 int err; 234 235 err = __serpent_setkey(&ctx->serpent_ctx, key, keylen - 236 SERPENT_BLOCK_SIZE); 237 if (err) 238 return err; 239 240 return lrw_init_table(&ctx->lrw_table, key + keylen - 241 SERPENT_BLOCK_SIZE); 242 } 243 244 static int lrw_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 245 struct scatterlist *src, unsigned int nbytes) 246 { 247 struct serpent_lrw_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 248 be128 buf[SERPENT_PARALLEL_BLOCKS]; 249 struct crypt_priv crypt_ctx = { 250 .ctx = &ctx->serpent_ctx, 251 .fpu_enabled = false, 252 }; 253 struct lrw_crypt_req req = { 254 .tbuf = buf, 255 .tbuflen = sizeof(buf), 256 257 .table_ctx = &ctx->lrw_table, 258 .crypt_ctx = &crypt_ctx, 259 .crypt_fn = encrypt_callback, 260 }; 261 int ret; 262 263 desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; 264 ret = lrw_crypt(desc, dst, src, nbytes, &req); 265 serpent_fpu_end(crypt_ctx.fpu_enabled); 266 267 return ret; 268 } 269 270 static int lrw_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 271 struct scatterlist *src, unsigned int nbytes) 272 { 273 struct serpent_lrw_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 274 be128 buf[SERPENT_PARALLEL_BLOCKS]; 275 struct crypt_priv crypt_ctx = { 276 .ctx = &ctx->serpent_ctx, 277 .fpu_enabled = false, 278 }; 279 struct lrw_crypt_req req = { 280 .tbuf = buf, 281 .tbuflen = sizeof(buf), 282 283 .table_ctx = &ctx->lrw_table, 284 .crypt_ctx = &crypt_ctx, 285 .crypt_fn = decrypt_callback, 286 }; 287 int ret; 288 289 desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; 290 ret = lrw_crypt(desc, dst, src, nbytes, &req); 291 serpent_fpu_end(crypt_ctx.fpu_enabled); 292 293 return ret; 294 } 295 296 static void lrw_exit_tfm(struct crypto_tfm *tfm) 297 { 298 struct serpent_lrw_ctx *ctx = crypto_tfm_ctx(tfm); 299 300 lrw_free_table(&ctx->lrw_table); 301 } 302 303 struct serpent_xts_ctx { 304 struct serpent_ctx tweak_ctx; 305 struct serpent_ctx crypt_ctx; 306 }; 307 308 static int xts_serpent_setkey(struct crypto_tfm *tfm, const u8 *key, 309 unsigned int keylen) 310 { 311 struct serpent_xts_ctx *ctx = crypto_tfm_ctx(tfm); 312 int err; 313 314 err = xts_check_key(tfm, key, keylen); 315 if (err) 316 return err; 317 318 /* first half of xts-key is for crypt */ 319 err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2); 320 if (err) 321 return err; 322 323 /* second half of xts-key is for tweak */ 324 return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2); 325 } 326 327 static int xts_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 328 struct scatterlist *src, unsigned int nbytes) 329 { 330 struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 331 be128 buf[SERPENT_PARALLEL_BLOCKS]; 332 struct crypt_priv crypt_ctx = { 333 .ctx = &ctx->crypt_ctx, 334 .fpu_enabled = false, 335 }; 336 struct xts_crypt_req req = { 337 .tbuf = buf, 338 .tbuflen = sizeof(buf), 339 340 .tweak_ctx = &ctx->tweak_ctx, 341 .tweak_fn = XTS_TWEAK_CAST(__serpent_encrypt), 342 .crypt_ctx = &crypt_ctx, 343 .crypt_fn = encrypt_callback, 344 }; 345 int ret; 346 347 desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; 348 ret = xts_crypt(desc, dst, src, nbytes, &req); 349 serpent_fpu_end(crypt_ctx.fpu_enabled); 350 351 return ret; 352 } 353 354 static int xts_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 355 struct scatterlist *src, unsigned int nbytes) 356 { 357 struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 358 be128 buf[SERPENT_PARALLEL_BLOCKS]; 359 struct crypt_priv crypt_ctx = { 360 .ctx = &ctx->crypt_ctx, 361 .fpu_enabled = false, 362 }; 363 struct xts_crypt_req req = { 364 .tbuf = buf, 365 .tbuflen = sizeof(buf), 366 367 .tweak_ctx = &ctx->tweak_ctx, 368 .tweak_fn = XTS_TWEAK_CAST(__serpent_encrypt), 369 .crypt_ctx = &crypt_ctx, 370 .crypt_fn = decrypt_callback, 371 }; 372 int ret; 373 374 desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; 375 ret = xts_crypt(desc, dst, src, nbytes, &req); 376 serpent_fpu_end(crypt_ctx.fpu_enabled); 377 378 return ret; 379 } 380 381 static struct crypto_alg serpent_algs[10] = { { 382 .cra_name = "__ecb-serpent-sse2", 383 .cra_driver_name = "__driver-ecb-serpent-sse2", 384 .cra_priority = 0, 385 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 386 CRYPTO_ALG_INTERNAL, 387 .cra_blocksize = SERPENT_BLOCK_SIZE, 388 .cra_ctxsize = sizeof(struct serpent_ctx), 389 .cra_alignmask = 0, 390 .cra_type = &crypto_blkcipher_type, 391 .cra_module = THIS_MODULE, 392 .cra_u = { 393 .blkcipher = { 394 .min_keysize = SERPENT_MIN_KEY_SIZE, 395 .max_keysize = SERPENT_MAX_KEY_SIZE, 396 .setkey = serpent_setkey, 397 .encrypt = ecb_encrypt, 398 .decrypt = ecb_decrypt, 399 }, 400 }, 401 }, { 402 .cra_name = "__cbc-serpent-sse2", 403 .cra_driver_name = "__driver-cbc-serpent-sse2", 404 .cra_priority = 0, 405 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 406 CRYPTO_ALG_INTERNAL, 407 .cra_blocksize = SERPENT_BLOCK_SIZE, 408 .cra_ctxsize = sizeof(struct serpent_ctx), 409 .cra_alignmask = 0, 410 .cra_type = &crypto_blkcipher_type, 411 .cra_module = THIS_MODULE, 412 .cra_u = { 413 .blkcipher = { 414 .min_keysize = SERPENT_MIN_KEY_SIZE, 415 .max_keysize = SERPENT_MAX_KEY_SIZE, 416 .setkey = serpent_setkey, 417 .encrypt = cbc_encrypt, 418 .decrypt = cbc_decrypt, 419 }, 420 }, 421 }, { 422 .cra_name = "__ctr-serpent-sse2", 423 .cra_driver_name = "__driver-ctr-serpent-sse2", 424 .cra_priority = 0, 425 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 426 CRYPTO_ALG_INTERNAL, 427 .cra_blocksize = 1, 428 .cra_ctxsize = sizeof(struct serpent_ctx), 429 .cra_alignmask = 0, 430 .cra_type = &crypto_blkcipher_type, 431 .cra_module = THIS_MODULE, 432 .cra_u = { 433 .blkcipher = { 434 .min_keysize = SERPENT_MIN_KEY_SIZE, 435 .max_keysize = SERPENT_MAX_KEY_SIZE, 436 .ivsize = SERPENT_BLOCK_SIZE, 437 .setkey = serpent_setkey, 438 .encrypt = ctr_crypt, 439 .decrypt = ctr_crypt, 440 }, 441 }, 442 }, { 443 .cra_name = "__lrw-serpent-sse2", 444 .cra_driver_name = "__driver-lrw-serpent-sse2", 445 .cra_priority = 0, 446 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 447 CRYPTO_ALG_INTERNAL, 448 .cra_blocksize = SERPENT_BLOCK_SIZE, 449 .cra_ctxsize = sizeof(struct serpent_lrw_ctx), 450 .cra_alignmask = 0, 451 .cra_type = &crypto_blkcipher_type, 452 .cra_module = THIS_MODULE, 453 .cra_exit = lrw_exit_tfm, 454 .cra_u = { 455 .blkcipher = { 456 .min_keysize = SERPENT_MIN_KEY_SIZE + 457 SERPENT_BLOCK_SIZE, 458 .max_keysize = SERPENT_MAX_KEY_SIZE + 459 SERPENT_BLOCK_SIZE, 460 .ivsize = SERPENT_BLOCK_SIZE, 461 .setkey = lrw_serpent_setkey, 462 .encrypt = lrw_encrypt, 463 .decrypt = lrw_decrypt, 464 }, 465 }, 466 }, { 467 .cra_name = "__xts-serpent-sse2", 468 .cra_driver_name = "__driver-xts-serpent-sse2", 469 .cra_priority = 0, 470 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | 471 CRYPTO_ALG_INTERNAL, 472 .cra_blocksize = SERPENT_BLOCK_SIZE, 473 .cra_ctxsize = sizeof(struct serpent_xts_ctx), 474 .cra_alignmask = 0, 475 .cra_type = &crypto_blkcipher_type, 476 .cra_module = THIS_MODULE, 477 .cra_u = { 478 .blkcipher = { 479 .min_keysize = SERPENT_MIN_KEY_SIZE * 2, 480 .max_keysize = SERPENT_MAX_KEY_SIZE * 2, 481 .ivsize = SERPENT_BLOCK_SIZE, 482 .setkey = xts_serpent_setkey, 483 .encrypt = xts_encrypt, 484 .decrypt = xts_decrypt, 485 }, 486 }, 487 }, { 488 .cra_name = "ecb(serpent)", 489 .cra_driver_name = "ecb-serpent-sse2", 490 .cra_priority = 400, 491 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 492 .cra_blocksize = SERPENT_BLOCK_SIZE, 493 .cra_ctxsize = sizeof(struct async_helper_ctx), 494 .cra_alignmask = 0, 495 .cra_type = &crypto_ablkcipher_type, 496 .cra_module = THIS_MODULE, 497 .cra_init = ablk_init, 498 .cra_exit = ablk_exit, 499 .cra_u = { 500 .ablkcipher = { 501 .min_keysize = SERPENT_MIN_KEY_SIZE, 502 .max_keysize = SERPENT_MAX_KEY_SIZE, 503 .setkey = ablk_set_key, 504 .encrypt = ablk_encrypt, 505 .decrypt = ablk_decrypt, 506 }, 507 }, 508 }, { 509 .cra_name = "cbc(serpent)", 510 .cra_driver_name = "cbc-serpent-sse2", 511 .cra_priority = 400, 512 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 513 .cra_blocksize = SERPENT_BLOCK_SIZE, 514 .cra_ctxsize = sizeof(struct async_helper_ctx), 515 .cra_alignmask = 0, 516 .cra_type = &crypto_ablkcipher_type, 517 .cra_module = THIS_MODULE, 518 .cra_init = ablk_init, 519 .cra_exit = ablk_exit, 520 .cra_u = { 521 .ablkcipher = { 522 .min_keysize = SERPENT_MIN_KEY_SIZE, 523 .max_keysize = SERPENT_MAX_KEY_SIZE, 524 .ivsize = SERPENT_BLOCK_SIZE, 525 .setkey = ablk_set_key, 526 .encrypt = __ablk_encrypt, 527 .decrypt = ablk_decrypt, 528 }, 529 }, 530 }, { 531 .cra_name = "ctr(serpent)", 532 .cra_driver_name = "ctr-serpent-sse2", 533 .cra_priority = 400, 534 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 535 .cra_blocksize = 1, 536 .cra_ctxsize = sizeof(struct async_helper_ctx), 537 .cra_alignmask = 0, 538 .cra_type = &crypto_ablkcipher_type, 539 .cra_module = THIS_MODULE, 540 .cra_init = ablk_init, 541 .cra_exit = ablk_exit, 542 .cra_u = { 543 .ablkcipher = { 544 .min_keysize = SERPENT_MIN_KEY_SIZE, 545 .max_keysize = SERPENT_MAX_KEY_SIZE, 546 .ivsize = SERPENT_BLOCK_SIZE, 547 .setkey = ablk_set_key, 548 .encrypt = ablk_encrypt, 549 .decrypt = ablk_encrypt, 550 .geniv = "chainiv", 551 }, 552 }, 553 }, { 554 .cra_name = "lrw(serpent)", 555 .cra_driver_name = "lrw-serpent-sse2", 556 .cra_priority = 400, 557 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 558 .cra_blocksize = SERPENT_BLOCK_SIZE, 559 .cra_ctxsize = sizeof(struct async_helper_ctx), 560 .cra_alignmask = 0, 561 .cra_type = &crypto_ablkcipher_type, 562 .cra_module = THIS_MODULE, 563 .cra_init = ablk_init, 564 .cra_exit = ablk_exit, 565 .cra_u = { 566 .ablkcipher = { 567 .min_keysize = SERPENT_MIN_KEY_SIZE + 568 SERPENT_BLOCK_SIZE, 569 .max_keysize = SERPENT_MAX_KEY_SIZE + 570 SERPENT_BLOCK_SIZE, 571 .ivsize = SERPENT_BLOCK_SIZE, 572 .setkey = ablk_set_key, 573 .encrypt = ablk_encrypt, 574 .decrypt = ablk_decrypt, 575 }, 576 }, 577 }, { 578 .cra_name = "xts(serpent)", 579 .cra_driver_name = "xts-serpent-sse2", 580 .cra_priority = 400, 581 .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 582 .cra_blocksize = SERPENT_BLOCK_SIZE, 583 .cra_ctxsize = sizeof(struct async_helper_ctx), 584 .cra_alignmask = 0, 585 .cra_type = &crypto_ablkcipher_type, 586 .cra_module = THIS_MODULE, 587 .cra_init = ablk_init, 588 .cra_exit = ablk_exit, 589 .cra_u = { 590 .ablkcipher = { 591 .min_keysize = SERPENT_MIN_KEY_SIZE * 2, 592 .max_keysize = SERPENT_MAX_KEY_SIZE * 2, 593 .ivsize = SERPENT_BLOCK_SIZE, 594 .setkey = ablk_set_key, 595 .encrypt = ablk_encrypt, 596 .decrypt = ablk_decrypt, 597 }, 598 }, 599 } }; 600 601 static int __init serpent_sse2_init(void) 602 { 603 if (!boot_cpu_has(X86_FEATURE_XMM2)) { 604 printk(KERN_INFO "SSE2 instructions are not detected.\n"); 605 return -ENODEV; 606 } 607 608 return crypto_register_algs(serpent_algs, ARRAY_SIZE(serpent_algs)); 609 } 610 611 static void __exit serpent_sse2_exit(void) 612 { 613 crypto_unregister_algs(serpent_algs, ARRAY_SIZE(serpent_algs)); 614 } 615 616 module_init(serpent_sse2_init); 617 module_exit(serpent_sse2_exit); 618 619 MODULE_DESCRIPTION("Serpent Cipher Algorithm, SSE2 optimized"); 620 MODULE_LICENSE("GPL"); 621 MODULE_ALIAS_CRYPTO("serpent"); 622