crypto: arm64/sm4 - Remove cfb(sm4) · tjh.dev/kernel@29fa12e

+2 -4

arch/arm64/crypto/Kconfig

··· 231 231 - NEON (Advanced SIMD) extensions 232 232 233 233 config CRYPTO_SM4_ARM64_CE_BLK 234 - tristate "Ciphers: SM4, modes: ECB/CBC/CFB/CTR/XTS (ARMv8 Crypto Extensions)" 234 + tristate "Ciphers: SM4, modes: ECB/CBC/CTR/XTS (ARMv8 Crypto Extensions)" 235 235 depends on KERNEL_MODE_NEON 236 236 select CRYPTO_SKCIPHER 237 237 select CRYPTO_SM4 ··· 240 240 with block cipher modes: 241 241 - ECB (Electronic Codebook) mode (NIST SP800-38A) 242 242 - CBC (Cipher Block Chaining) mode (NIST SP800-38A) 243 - - CFB (Cipher Feedback) mode (NIST SP800-38A) 244 243 - CTR (Counter) mode (NIST SP800-38A) 245 244 - XTS (XOR Encrypt XOR with ciphertext stealing) mode (NIST SP800-38E 246 245 and IEEE 1619) ··· 249 250 - NEON (Advanced SIMD) extensions 250 251 251 252 config CRYPTO_SM4_ARM64_NEON_BLK 252 - tristate "Ciphers: SM4, modes: ECB/CBC/CFB/CTR (NEON)" 253 + tristate "Ciphers: SM4, modes: ECB/CBC/CTR (NEON)" 253 254 depends on KERNEL_MODE_NEON 254 255 select CRYPTO_SKCIPHER 255 256 select CRYPTO_SM4 ··· 258 259 with block cipher modes: 259 260 - ECB (Electronic Codebook) mode (NIST SP800-38A) 260 261 - CBC (Cipher Block Chaining) mode (NIST SP800-38A) 261 - - CFB (Cipher Feedback) mode (NIST SP800-38A) 262 262 - CTR (Counter) mode (NIST SP800-38A) 263 263 264 264 Architecture: arm64 using:

-158

arch/arm64/crypto/sm4-ce-core.S

··· 403 403 SYM_FUNC_END(sm4_ce_cbc_cts_dec) 404 404 405 405 .align 3 406 - SYM_FUNC_START(sm4_ce_cfb_enc) 407 - /* input: 408 - * x0: round key array, CTX 409 - * x1: dst 410 - * x2: src 411 - * x3: iv (big endian, 128 bit) 412 - * w4: nblocks 413 - */ 414 - SM4_PREPARE(x0) 415 - 416 - ld1 {RIV.16b}, [x3] 417 - 418 - .Lcfb_enc_loop_4x: 419 - cmp w4, #4 420 - blt .Lcfb_enc_loop_1x 421 - 422 - sub w4, w4, #4 423 - 424 - ld1 {v0.16b-v3.16b}, [x2], #64 425 - 426 - rev32 v8.16b, RIV.16b 427 - SM4_CRYPT_BLK_BE(v8) 428 - eor v0.16b, v0.16b, v8.16b 429 - 430 - rev32 v8.16b, v0.16b 431 - SM4_CRYPT_BLK_BE(v8) 432 - eor v1.16b, v1.16b, v8.16b 433 - 434 - rev32 v8.16b, v1.16b 435 - SM4_CRYPT_BLK_BE(v8) 436 - eor v2.16b, v2.16b, v8.16b 437 - 438 - rev32 v8.16b, v2.16b 439 - SM4_CRYPT_BLK_BE(v8) 440 - eor v3.16b, v3.16b, v8.16b 441 - 442 - st1 {v0.16b-v3.16b}, [x1], #64 443 - mov RIV.16b, v3.16b 444 - 445 - cbz w4, .Lcfb_enc_end 446 - b .Lcfb_enc_loop_4x 447 - 448 - .Lcfb_enc_loop_1x: 449 - sub w4, w4, #1 450 - 451 - ld1 {v0.16b}, [x2], #16 452 - 453 - SM4_CRYPT_BLK(RIV) 454 - eor RIV.16b, RIV.16b, v0.16b 455 - 456 - st1 {RIV.16b}, [x1], #16 457 - 458 - cbnz w4, .Lcfb_enc_loop_1x 459 - 460 - .Lcfb_enc_end: 461 - /* store new IV */ 462 - st1 {RIV.16b}, [x3] 463 - 464 - ret 465 - SYM_FUNC_END(sm4_ce_cfb_enc) 466 - 467 - .align 3 468 - SYM_FUNC_START(sm4_ce_cfb_dec) 469 - /* input: 470 - * x0: round key array, CTX 471 - * x1: dst 472 - * x2: src 473 - * x3: iv (big endian, 128 bit) 474 - * w4: nblocks 475 - */ 476 - SM4_PREPARE(x0) 477 - 478 - ld1 {RIV.16b}, [x3] 479 - 480 - .Lcfb_dec_loop_8x: 481 - sub w4, w4, #8 482 - tbnz w4, #31, .Lcfb_dec_4x 483 - 484 - ld1 {v0.16b-v3.16b}, [x2], #64 485 - ld1 {v4.16b-v7.16b}, [x2], #64 486 - 487 - rev32 v8.16b, RIV.16b 488 - rev32 v9.16b, v0.16b 489 - rev32 v10.16b, v1.16b 490 - rev32 v11.16b, v2.16b 491 - rev32 v12.16b, v3.16b 492 - rev32 v13.16b, v4.16b 493 - rev32 v14.16b, v5.16b 494 - rev32 v15.16b, v6.16b 495 - 496 - SM4_CRYPT_BLK8_BE(v8, v9, v10, v11, v12, v13, v14, v15) 497 - 498 - mov RIV.16b, v7.16b 499 - 500 - eor v0.16b, v0.16b, v8.16b 501 - eor v1.16b, v1.16b, v9.16b 502 - eor v2.16b, v2.16b, v10.16b 503 - eor v3.16b, v3.16b, v11.16b 504 - eor v4.16b, v4.16b, v12.16b 505 - eor v5.16b, v5.16b, v13.16b 506 - eor v6.16b, v6.16b, v14.16b 507 - eor v7.16b, v7.16b, v15.16b 508 - 509 - st1 {v0.16b-v3.16b}, [x1], #64 510 - st1 {v4.16b-v7.16b}, [x1], #64 511 - 512 - cbz w4, .Lcfb_dec_end 513 - b .Lcfb_dec_loop_8x 514 - 515 - .Lcfb_dec_4x: 516 - add w4, w4, #8 517 - cmp w4, #4 518 - blt .Lcfb_dec_loop_1x 519 - 520 - sub w4, w4, #4 521 - 522 - ld1 {v0.16b-v3.16b}, [x2], #64 523 - 524 - rev32 v8.16b, RIV.16b 525 - rev32 v9.16b, v0.16b 526 - rev32 v10.16b, v1.16b 527 - rev32 v11.16b, v2.16b 528 - 529 - SM4_CRYPT_BLK4_BE(v8, v9, v10, v11) 530 - 531 - mov RIV.16b, v3.16b 532 - 533 - eor v0.16b, v0.16b, v8.16b 534 - eor v1.16b, v1.16b, v9.16b 535 - eor v2.16b, v2.16b, v10.16b 536 - eor v3.16b, v3.16b, v11.16b 537 - 538 - st1 {v0.16b-v3.16b}, [x1], #64 539 - 540 - cbz w4, .Lcfb_dec_end 541 - 542 - .Lcfb_dec_loop_1x: 543 - sub w4, w4, #1 544 - 545 - ld1 {v0.16b}, [x2], #16 546 - 547 - SM4_CRYPT_BLK(RIV) 548 - 549 - eor RIV.16b, RIV.16b, v0.16b 550 - st1 {RIV.16b}, [x1], #16 551 - 552 - mov RIV.16b, v0.16b 553 - 554 - cbnz w4, .Lcfb_dec_loop_1x 555 - 556 - .Lcfb_dec_end: 557 - /* store new IV */ 558 - st1 {RIV.16b}, [x3] 559 - 560 - ret 561 - SYM_FUNC_END(sm4_ce_cfb_dec) 562 - 563 - .align 3 564 406 SYM_FUNC_START(sm4_ce_ctr_enc) 565 407 /* input: 566 408 * x0: round key array, CTX

+1 -107

arch/arm64/crypto/sm4-ce-glue.c

··· 37 37 u8 *iv, unsigned int nbytes); 38 38 asmlinkage void sm4_ce_cbc_cts_dec(const u32 *rkey, u8 *dst, const u8 *src, 39 39 u8 *iv, unsigned int nbytes); 40 - asmlinkage void sm4_ce_cfb_enc(const u32 *rkey, u8 *dst, const u8 *src, 41 - u8 *iv, unsigned int nblks); 42 - asmlinkage void sm4_ce_cfb_dec(const u32 *rkey, u8 *dst, const u8 *src, 43 - u8 *iv, unsigned int nblks); 44 40 asmlinkage void sm4_ce_ctr_enc(const u32 *rkey, u8 *dst, const u8 *src, 45 41 u8 *iv, unsigned int nblks); 46 42 asmlinkage void sm4_ce_xts_enc(const u32 *rkey1, u8 *dst, const u8 *src, ··· 52 56 EXPORT_SYMBOL(sm4_ce_expand_key); 53 57 EXPORT_SYMBOL(sm4_ce_crypt_block); 54 58 EXPORT_SYMBOL(sm4_ce_cbc_enc); 55 - EXPORT_SYMBOL(sm4_ce_cfb_enc); 56 59 57 60 struct sm4_xts_ctx { 58 61 struct sm4_ctx key1; ··· 275 280 return sm4_cbc_cts_crypt(req, false); 276 281 } 277 282 278 - static int sm4_cfb_encrypt(struct skcipher_request *req) 279 - { 280 - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 281 - struct sm4_ctx *ctx = crypto_skcipher_ctx(tfm); 282 - struct skcipher_walk walk; 283 - unsigned int nbytes; 284 - int err; 285 - 286 - err = skcipher_walk_virt(&walk, req, false); 287 - 288 - while ((nbytes = walk.nbytes) > 0) { 289 - const u8 *src = walk.src.virt.addr; 290 - u8 *dst = walk.dst.virt.addr; 291 - unsigned int nblks; 292 - 293 - kernel_neon_begin(); 294 - 295 - nblks = BYTES2BLKS(nbytes); 296 - if (nblks) { 297 - sm4_ce_cfb_enc(ctx->rkey_enc, dst, src, walk.iv, nblks); 298 - dst += nblks * SM4_BLOCK_SIZE; 299 - src += nblks * SM4_BLOCK_SIZE; 300 - nbytes -= nblks * SM4_BLOCK_SIZE; 301 - } 302 - 303 - /* tail */ 304 - if (walk.nbytes == walk.total && nbytes > 0) { 305 - u8 keystream[SM4_BLOCK_SIZE]; 306 - 307 - sm4_ce_crypt_block(ctx->rkey_enc, keystream, walk.iv); 308 - crypto_xor_cpy(dst, src, keystream, nbytes); 309 - nbytes = 0; 310 - } 311 - 312 - kernel_neon_end(); 313 - 314 - err = skcipher_walk_done(&walk, nbytes); 315 - } 316 - 317 - return err; 318 - } 319 - 320 - static int sm4_cfb_decrypt(struct skcipher_request *req) 321 - { 322 - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 323 - struct sm4_ctx *ctx = crypto_skcipher_ctx(tfm); 324 - struct skcipher_walk walk; 325 - unsigned int nbytes; 326 - int err; 327 - 328 - err = skcipher_walk_virt(&walk, req, false); 329 - 330 - while ((nbytes = walk.nbytes) > 0) { 331 - const u8 *src = walk.src.virt.addr; 332 - u8 *dst = walk.dst.virt.addr; 333 - unsigned int nblks; 334 - 335 - kernel_neon_begin(); 336 - 337 - nblks = BYTES2BLKS(nbytes); 338 - if (nblks) { 339 - sm4_ce_cfb_dec(ctx->rkey_enc, dst, src, walk.iv, nblks); 340 - dst += nblks * SM4_BLOCK_SIZE; 341 - src += nblks * SM4_BLOCK_SIZE; 342 - nbytes -= nblks * SM4_BLOCK_SIZE; 343 - } 344 - 345 - /* tail */ 346 - if (walk.nbytes == walk.total && nbytes > 0) { 347 - u8 keystream[SM4_BLOCK_SIZE]; 348 - 349 - sm4_ce_crypt_block(ctx->rkey_enc, keystream, walk.iv); 350 - crypto_xor_cpy(dst, src, keystream, nbytes); 351 - nbytes = 0; 352 - } 353 - 354 - kernel_neon_end(); 355 - 356 - err = skcipher_walk_done(&walk, nbytes); 357 - } 358 - 359 - return err; 360 - } 361 - 362 283 static int sm4_ctr_crypt(struct skcipher_request *req) 363 284 { 364 285 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); ··· 453 542 .setkey = sm4_setkey, 454 543 .encrypt = sm4_cbc_encrypt, 455 544 .decrypt = sm4_cbc_decrypt, 456 - }, { 457 - .base = { 458 - .cra_name = "cfb(sm4)", 459 - .cra_driver_name = "cfb-sm4-ce", 460 - .cra_priority = 400, 461 - .cra_blocksize = 1, 462 - .cra_ctxsize = sizeof(struct sm4_ctx), 463 - .cra_module = THIS_MODULE, 464 - }, 465 - .min_keysize = SM4_KEY_SIZE, 466 - .max_keysize = SM4_KEY_SIZE, 467 - .ivsize = SM4_BLOCK_SIZE, 468 - .chunksize = SM4_BLOCK_SIZE, 469 - .setkey = sm4_setkey, 470 - .encrypt = sm4_cfb_encrypt, 471 - .decrypt = sm4_cfb_decrypt, 472 545 }, { 473 546 .base = { 474 547 .cra_name = "ctr(sm4)", ··· 764 869 module_cpu_feature_match(SM4, sm4_init); 765 870 module_exit(sm4_exit); 766 871 767 - MODULE_DESCRIPTION("SM4 ECB/CBC/CFB/CTR/XTS using ARMv8 Crypto Extensions"); 872 + MODULE_DESCRIPTION("SM4 ECB/CBC/CTR/XTS using ARMv8 Crypto Extensions"); 768 873 MODULE_ALIAS_CRYPTO("sm4-ce"); 769 874 MODULE_ALIAS_CRYPTO("sm4"); 770 875 MODULE_ALIAS_CRYPTO("ecb(sm4)"); 771 876 MODULE_ALIAS_CRYPTO("cbc(sm4)"); 772 - MODULE_ALIAS_CRYPTO("cfb(sm4)"); 773 877 MODULE_ALIAS_CRYPTO("ctr(sm4)"); 774 878 MODULE_ALIAS_CRYPTO("cts(cbc(sm4))"); 775 879 MODULE_ALIAS_CRYPTO("xts(sm4)");

-3

arch/arm64/crypto/sm4-ce.h

··· 11 11 12 12 void sm4_ce_cbc_enc(const u32 *rkey_enc, u8 *dst, const u8 *src, 13 13 u8 *iv, unsigned int nblocks); 14 - 15 - void sm4_ce_cfb_enc(const u32 *rkey_enc, u8 *dst, const u8 *src, 16 - u8 *iv, unsigned int nblocks);

-113

arch/arm64/crypto/sm4-neon-core.S

··· 438 438 SYM_FUNC_END(sm4_neon_cbc_dec) 439 439 440 440 .align 3 441 - SYM_FUNC_START(sm4_neon_cfb_dec) 442 - /* input: 443 - * x0: round key array, CTX 444 - * x1: dst 445 - * x2: src 446 - * x3: iv (big endian, 128 bit) 447 - * w4: nblocks 448 - */ 449 - SM4_PREPARE() 450 - 451 - ld1 {v0.16b}, [x3] 452 - 453 - .Lcfb_dec_loop_8x: 454 - sub w4, w4, #8 455 - tbnz w4, #31, .Lcfb_dec_4x 456 - 457 - ld1 {v1.16b-v3.16b}, [x2], #48 458 - ld4 {v4.4s-v7.4s}, [x2] 459 - 460 - transpose_4x4(v0, v1, v2, v3) 461 - 462 - SM4_CRYPT_BLK8(v0, v1, v2, v3, v4, v5, v6, v7) 463 - 464 - sub x2, x2, #48 465 - ld1 {RTMP0.16b-RTMP3.16b}, [x2], #64 466 - ld1 {RTMP4.16b-RTMP7.16b}, [x2], #64 467 - 468 - eor v0.16b, v0.16b, RTMP0.16b 469 - eor v1.16b, v1.16b, RTMP1.16b 470 - eor v2.16b, v2.16b, RTMP2.16b 471 - eor v3.16b, v3.16b, RTMP3.16b 472 - eor v4.16b, v4.16b, RTMP4.16b 473 - eor v5.16b, v5.16b, RTMP5.16b 474 - eor v6.16b, v6.16b, RTMP6.16b 475 - eor v7.16b, v7.16b, RTMP7.16b 476 - 477 - st1 {v0.16b-v3.16b}, [x1], #64 478 - st1 {v4.16b-v7.16b}, [x1], #64 479 - 480 - mov v0.16b, RTMP7.16b 481 - 482 - cbz w4, .Lcfb_dec_end 483 - b .Lcfb_dec_loop_8x 484 - 485 - .Lcfb_dec_4x: 486 - add w4, w4, #8 487 - cmp w4, #4 488 - blt .Lcfb_dec_tail 489 - 490 - sub w4, w4, #4 491 - 492 - ld1 {v4.16b-v7.16b}, [x2], #64 493 - 494 - rev32 v0.16b, v0.16b /* v0 is IV register */ 495 - rev32 v1.16b, v4.16b 496 - rev32 v2.16b, v5.16b 497 - rev32 v3.16b, v6.16b 498 - 499 - transpose_4x4(v0, v1, v2, v3) 500 - 501 - SM4_CRYPT_BLK4_BE(v0, v1, v2, v3) 502 - 503 - eor v0.16b, v0.16b, v4.16b 504 - eor v1.16b, v1.16b, v5.16b 505 - eor v2.16b, v2.16b, v6.16b 506 - eor v3.16b, v3.16b, v7.16b 507 - 508 - st1 {v0.16b-v3.16b}, [x1], #64 509 - 510 - mov v0.16b, v7.16b 511 - 512 - cbz w4, .Lcfb_dec_end 513 - 514 - .Lcfb_dec_tail: 515 - cmp w4, #2 516 - ld1 {v4.16b}, [x2], #16 517 - blt .Lcfb_dec_tail_load_done 518 - ld1 {v5.16b}, [x2], #16 519 - beq .Lcfb_dec_tail_load_done 520 - ld1 {v6.16b}, [x2], #16 521 - 522 - .Lcfb_dec_tail_load_done: 523 - rev32 v0.16b, v0.16b /* v0 is IV register */ 524 - rev32 v1.16b, v4.16b 525 - rev32 v2.16b, v5.16b 526 - 527 - transpose_4x4(v0, v1, v2, v3) 528 - 529 - SM4_CRYPT_BLK4_BE(v0, v1, v2, v3) 530 - 531 - cmp w4, #2 532 - eor v0.16b, v0.16b, v4.16b 533 - st1 {v0.16b}, [x1], #16 534 - mov v0.16b, v4.16b 535 - blt .Lcfb_dec_end 536 - 537 - eor v1.16b, v1.16b, v5.16b 538 - st1 {v1.16b}, [x1], #16 539 - mov v0.16b, v5.16b 540 - beq .Lcfb_dec_end 541 - 542 - eor v2.16b, v2.16b, v6.16b 543 - st1 {v2.16b}, [x1], #16 544 - mov v0.16b, v6.16b 545 - 546 - .Lcfb_dec_end: 547 - /* store new IV */ 548 - st1 {v0.16b}, [x3] 549 - 550 - ret 551 - SYM_FUNC_END(sm4_neon_cfb_dec) 552 - 553 - .align 3 554 441 SYM_FUNC_START(sm4_neon_ctr_crypt) 555 442 /* input: 556 443 * x0: round key array, CTX

+1 -104

arch/arm64/crypto/sm4-neon-glue.c

··· 22 22 unsigned int nblocks); 23 23 asmlinkage void sm4_neon_cbc_dec(const u32 *rkey_dec, u8 *dst, const u8 *src, 24 24 u8 *iv, unsigned int nblocks); 25 - asmlinkage void sm4_neon_cfb_dec(const u32 *rkey_enc, u8 *dst, const u8 *src, 26 - u8 *iv, unsigned int nblocks); 27 25 asmlinkage void sm4_neon_ctr_crypt(const u32 *rkey_enc, u8 *dst, const u8 *src, 28 26 u8 *iv, unsigned int nblocks); 29 27 ··· 140 142 return err; 141 143 } 142 144 143 - static int sm4_cfb_encrypt(struct skcipher_request *req) 144 - { 145 - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 146 - struct sm4_ctx *ctx = crypto_skcipher_ctx(tfm); 147 - struct skcipher_walk walk; 148 - unsigned int nbytes; 149 - int err; 150 - 151 - err = skcipher_walk_virt(&walk, req, false); 152 - 153 - while ((nbytes = walk.nbytes) > 0) { 154 - u8 keystream[SM4_BLOCK_SIZE]; 155 - const u8 *iv = walk.iv; 156 - const u8 *src = walk.src.virt.addr; 157 - u8 *dst = walk.dst.virt.addr; 158 - 159 - while (nbytes >= SM4_BLOCK_SIZE) { 160 - sm4_crypt_block(ctx->rkey_enc, keystream, iv); 161 - crypto_xor_cpy(dst, src, keystream, SM4_BLOCK_SIZE); 162 - iv = dst; 163 - src += SM4_BLOCK_SIZE; 164 - dst += SM4_BLOCK_SIZE; 165 - nbytes -= SM4_BLOCK_SIZE; 166 - } 167 - if (iv != walk.iv) 168 - memcpy(walk.iv, iv, SM4_BLOCK_SIZE); 169 - 170 - /* tail */ 171 - if (walk.nbytes == walk.total && nbytes > 0) { 172 - sm4_crypt_block(ctx->rkey_enc, keystream, walk.iv); 173 - crypto_xor_cpy(dst, src, keystream, nbytes); 174 - nbytes = 0; 175 - } 176 - 177 - err = skcipher_walk_done(&walk, nbytes); 178 - } 179 - 180 - return err; 181 - } 182 - 183 - static int sm4_cfb_decrypt(struct skcipher_request *req) 184 - { 185 - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 186 - struct sm4_ctx *ctx = crypto_skcipher_ctx(tfm); 187 - struct skcipher_walk walk; 188 - unsigned int nbytes; 189 - int err; 190 - 191 - err = skcipher_walk_virt(&walk, req, false); 192 - 193 - while ((nbytes = walk.nbytes) > 0) { 194 - const u8 *src = walk.src.virt.addr; 195 - u8 *dst = walk.dst.virt.addr; 196 - unsigned int nblocks; 197 - 198 - nblocks = nbytes / SM4_BLOCK_SIZE; 199 - if (nblocks) { 200 - kernel_neon_begin(); 201 - 202 - sm4_neon_cfb_dec(ctx->rkey_enc, dst, src, 203 - walk.iv, nblocks); 204 - 205 - kernel_neon_end(); 206 - 207 - dst += nblocks * SM4_BLOCK_SIZE; 208 - src += nblocks * SM4_BLOCK_SIZE; 209 - nbytes -= nblocks * SM4_BLOCK_SIZE; 210 - } 211 - 212 - /* tail */ 213 - if (walk.nbytes == walk.total && nbytes > 0) { 214 - u8 keystream[SM4_BLOCK_SIZE]; 215 - 216 - sm4_crypt_block(ctx->rkey_enc, keystream, walk.iv); 217 - crypto_xor_cpy(dst, src, keystream, nbytes); 218 - nbytes = 0; 219 - } 220 - 221 - err = skcipher_walk_done(&walk, nbytes); 222 - } 223 - 224 - return err; 225 - } 226 - 227 145 static int sm4_ctr_crypt(struct skcipher_request *req) 228 146 { 229 147 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); ··· 217 303 .decrypt = sm4_cbc_decrypt, 218 304 }, { 219 305 .base = { 220 - .cra_name = "cfb(sm4)", 221 - .cra_driver_name = "cfb-sm4-neon", 222 - .cra_priority = 200, 223 - .cra_blocksize = 1, 224 - .cra_ctxsize = sizeof(struct sm4_ctx), 225 - .cra_module = THIS_MODULE, 226 - }, 227 - .min_keysize = SM4_KEY_SIZE, 228 - .max_keysize = SM4_KEY_SIZE, 229 - .ivsize = SM4_BLOCK_SIZE, 230 - .chunksize = SM4_BLOCK_SIZE, 231 - .setkey = sm4_setkey, 232 - .encrypt = sm4_cfb_encrypt, 233 - .decrypt = sm4_cfb_decrypt, 234 - }, { 235 - .base = { 236 306 .cra_name = "ctr(sm4)", 237 307 .cra_driver_name = "ctr-sm4-neon", 238 308 .cra_priority = 200, ··· 247 349 module_init(sm4_init); 248 350 module_exit(sm4_exit); 249 351 250 - MODULE_DESCRIPTION("SM4 ECB/CBC/CFB/CTR using ARMv8 NEON"); 352 + MODULE_DESCRIPTION("SM4 ECB/CBC/CTR using ARMv8 NEON"); 251 353 MODULE_ALIAS_CRYPTO("sm4-neon"); 252 354 MODULE_ALIAS_CRYPTO("sm4"); 253 355 MODULE_ALIAS_CRYPTO("ecb(sm4)"); 254 356 MODULE_ALIAS_CRYPTO("cbc(sm4)"); 255 - MODULE_ALIAS_CRYPTO("cfb(sm4)"); 256 357 MODULE_ALIAS_CRYPTO("ctr(sm4)"); 257 358 MODULE_AUTHOR("Tianjia Zhang <tianjia.zhang@linux.alibaba.com>"); 258 359 MODULE_LICENSE("GPL v2");