1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Glue Code for assembler optimized version of 3DES 4 * 5 * Copyright © 2014 Jussi Kivilinna <jussi.kivilinna@mbnet.fi> 6 * 7 * CBC & ECB parts based on code (crypto/cbc.c,ecb.c) by: 8 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> 9 * CTR part based on code (crypto/ctr.c) by: 10 * (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com> 11 */ 12 13 #include <crypto/algapi.h> 14 #include <crypto/internal/des.h> 15 #include <crypto/internal/skcipher.h> 16 #include <linux/crypto.h> 17 #include <linux/init.h> 18 #include <linux/module.h> 19 #include <linux/types.h> 20 21 struct des3_ede_x86_ctx { 22 u32 enc_expkey[DES3_EDE_EXPKEY_WORDS]; 23 u32 dec_expkey[DES3_EDE_EXPKEY_WORDS]; 24 }; 25 26 /* regular block cipher functions */ 27 asmlinkage void des3_ede_x86_64_crypt_blk(const u32 *expkey, u8 *dst, 28 const u8 *src); 29 30 /* 3-way parallel cipher functions */ 31 asmlinkage void des3_ede_x86_64_crypt_blk_3way(const u32 *expkey, u8 *dst, 32 const u8 *src); 33 34 static inline void des3_ede_enc_blk(struct des3_ede_x86_ctx *ctx, u8 *dst, 35 const u8 *src) 36 { 37 u32 *enc_ctx = ctx->enc_expkey; 38 39 des3_ede_x86_64_crypt_blk(enc_ctx, dst, src); 40 } 41 42 static inline void des3_ede_dec_blk(struct des3_ede_x86_ctx *ctx, u8 *dst, 43 const u8 *src) 44 { 45 u32 *dec_ctx = ctx->dec_expkey; 46 47 des3_ede_x86_64_crypt_blk(dec_ctx, dst, src); 48 } 49 50 static inline void des3_ede_enc_blk_3way(struct des3_ede_x86_ctx *ctx, u8 *dst, 51 const u8 *src) 52 { 53 u32 *enc_ctx = ctx->enc_expkey; 54 55 des3_ede_x86_64_crypt_blk_3way(enc_ctx, dst, src); 56 } 57 58 static inline void des3_ede_dec_blk_3way(struct des3_ede_x86_ctx *ctx, u8 *dst, 59 const u8 *src) 60 { 61 u32 *dec_ctx = ctx->dec_expkey; 62 63 des3_ede_x86_64_crypt_blk_3way(dec_ctx, dst, src); 64 } 65 66 static void des3_ede_x86_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 67 { 68 des3_ede_enc_blk(crypto_tfm_ctx(tfm), dst, src); 69 } 70 71 static void des3_ede_x86_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 72 { 73 des3_ede_dec_blk(crypto_tfm_ctx(tfm), dst, src); 74 } 75 76 static int ecb_crypt(struct skcipher_request *req, const u32 *expkey) 77 { 78 const unsigned int bsize = DES3_EDE_BLOCK_SIZE; 79 struct skcipher_walk walk; 80 unsigned int nbytes; 81 int err; 82 83 err = skcipher_walk_virt(&walk, req, false); 84 85 while ((nbytes = walk.nbytes)) { 86 u8 *wsrc = walk.src.virt.addr; 87 u8 *wdst = walk.dst.virt.addr; 88 89 /* Process four block batch */ 90 if (nbytes >= bsize * 3) { 91 do { 92 des3_ede_x86_64_crypt_blk_3way(expkey, wdst, 93 wsrc); 94 95 wsrc += bsize * 3; 96 wdst += bsize * 3; 97 nbytes -= bsize * 3; 98 } while (nbytes >= bsize * 3); 99 100 if (nbytes < bsize) 101 goto done; 102 } 103 104 /* Handle leftovers */ 105 do { 106 des3_ede_x86_64_crypt_blk(expkey, wdst, wsrc); 107 108 wsrc += bsize; 109 wdst += bsize; 110 nbytes -= bsize; 111 } while (nbytes >= bsize); 112 113 done: 114 err = skcipher_walk_done(&walk, nbytes); 115 } 116 117 return err; 118 } 119 120 static int ecb_encrypt(struct skcipher_request *req) 121 { 122 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 123 struct des3_ede_x86_ctx *ctx = crypto_skcipher_ctx(tfm); 124 125 return ecb_crypt(req, ctx->enc_expkey); 126 } 127 128 static int ecb_decrypt(struct skcipher_request *req) 129 { 130 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 131 struct des3_ede_x86_ctx *ctx = crypto_skcipher_ctx(tfm); 132 133 return ecb_crypt(req, ctx->dec_expkey); 134 } 135 136 static unsigned int __cbc_encrypt(struct des3_ede_x86_ctx *ctx, 137 struct skcipher_walk *walk) 138 { 139 unsigned int bsize = DES3_EDE_BLOCK_SIZE; 140 unsigned int nbytes = walk->nbytes; 141 u64 *src = (u64 *)walk->src.virt.addr; 142 u64 *dst = (u64 *)walk->dst.virt.addr; 143 u64 *iv = (u64 *)walk->iv; 144 145 do { 146 *dst = *src ^ *iv; 147 des3_ede_enc_blk(ctx, (u8 *)dst, (u8 *)dst); 148 iv = dst; 149 150 src += 1; 151 dst += 1; 152 nbytes -= bsize; 153 } while (nbytes >= bsize); 154 155 *(u64 *)walk->iv = *iv; 156 return nbytes; 157 } 158 159 static int cbc_encrypt(struct skcipher_request *req) 160 { 161 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 162 struct des3_ede_x86_ctx *ctx = crypto_skcipher_ctx(tfm); 163 struct skcipher_walk walk; 164 unsigned int nbytes; 165 int err; 166 167 err = skcipher_walk_virt(&walk, req, false); 168 169 while ((nbytes = walk.nbytes)) { 170 nbytes = __cbc_encrypt(ctx, &walk); 171 err = skcipher_walk_done(&walk, nbytes); 172 } 173 174 return err; 175 } 176 177 static unsigned int __cbc_decrypt(struct des3_ede_x86_ctx *ctx, 178 struct skcipher_walk *walk) 179 { 180 unsigned int bsize = DES3_EDE_BLOCK_SIZE; 181 unsigned int nbytes = walk->nbytes; 182 u64 *src = (u64 *)walk->src.virt.addr; 183 u64 *dst = (u64 *)walk->dst.virt.addr; 184 u64 ivs[3 - 1]; 185 u64 last_iv; 186 187 /* Start of the last block. */ 188 src += nbytes / bsize - 1; 189 dst += nbytes / bsize - 1; 190 191 last_iv = *src; 192 193 /* Process four block batch */ 194 if (nbytes >= bsize * 3) { 195 do { 196 nbytes -= bsize * 3 - bsize; 197 src -= 3 - 1; 198 dst -= 3 - 1; 199 200 ivs[0] = src[0]; 201 ivs[1] = src[1]; 202 203 des3_ede_dec_blk_3way(ctx, (u8 *)dst, (u8 *)src); 204 205 dst[1] ^= ivs[0]; 206 dst[2] ^= ivs[1]; 207 208 nbytes -= bsize; 209 if (nbytes < bsize) 210 goto done; 211 212 *dst ^= *(src - 1); 213 src -= 1; 214 dst -= 1; 215 } while (nbytes >= bsize * 3); 216 } 217 218 /* Handle leftovers */ 219 for (;;) { 220 des3_ede_dec_blk(ctx, (u8 *)dst, (u8 *)src); 221 222 nbytes -= bsize; 223 if (nbytes < bsize) 224 break; 225 226 *dst ^= *(src - 1); 227 src -= 1; 228 dst -= 1; 229 } 230 231 done: 232 *dst ^= *(u64 *)walk->iv; 233 *(u64 *)walk->iv = last_iv; 234 235 return nbytes; 236 } 237 238 static int cbc_decrypt(struct skcipher_request *req) 239 { 240 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 241 struct des3_ede_x86_ctx *ctx = crypto_skcipher_ctx(tfm); 242 struct skcipher_walk walk; 243 unsigned int nbytes; 244 int err; 245 246 err = skcipher_walk_virt(&walk, req, false); 247 248 while ((nbytes = walk.nbytes)) { 249 nbytes = __cbc_decrypt(ctx, &walk); 250 err = skcipher_walk_done(&walk, nbytes); 251 } 252 253 return err; 254 } 255 256 static void ctr_crypt_final(struct des3_ede_x86_ctx *ctx, 257 struct skcipher_walk *walk) 258 { 259 u8 *ctrblk = walk->iv; 260 u8 keystream[DES3_EDE_BLOCK_SIZE]; 261 u8 *src = walk->src.virt.addr; 262 u8 *dst = walk->dst.virt.addr; 263 unsigned int nbytes = walk->nbytes; 264 265 des3_ede_enc_blk(ctx, keystream, ctrblk); 266 crypto_xor_cpy(dst, keystream, src, nbytes); 267 268 crypto_inc(ctrblk, DES3_EDE_BLOCK_SIZE); 269 } 270 271 static unsigned int __ctr_crypt(struct des3_ede_x86_ctx *ctx, 272 struct skcipher_walk *walk) 273 { 274 unsigned int bsize = DES3_EDE_BLOCK_SIZE; 275 unsigned int nbytes = walk->nbytes; 276 __be64 *src = (__be64 *)walk->src.virt.addr; 277 __be64 *dst = (__be64 *)walk->dst.virt.addr; 278 u64 ctrblk = be64_to_cpu(*(__be64 *)walk->iv); 279 __be64 ctrblocks[3]; 280 281 /* Process four block batch */ 282 if (nbytes >= bsize * 3) { 283 do { 284 /* create ctrblks for parallel encrypt */ 285 ctrblocks[0] = cpu_to_be64(ctrblk++); 286 ctrblocks[1] = cpu_to_be64(ctrblk++); 287 ctrblocks[2] = cpu_to_be64(ctrblk++); 288 289 des3_ede_enc_blk_3way(ctx, (u8 *)ctrblocks, 290 (u8 *)ctrblocks); 291 292 dst[0] = src[0] ^ ctrblocks[0]; 293 dst[1] = src[1] ^ ctrblocks[1]; 294 dst[2] = src[2] ^ ctrblocks[2]; 295 296 src += 3; 297 dst += 3; 298 } while ((nbytes -= bsize * 3) >= bsize * 3); 299 300 if (nbytes < bsize) 301 goto done; 302 } 303 304 /* Handle leftovers */ 305 do { 306 ctrblocks[0] = cpu_to_be64(ctrblk++); 307 308 des3_ede_enc_blk(ctx, (u8 *)ctrblocks, (u8 *)ctrblocks); 309 310 dst[0] = src[0] ^ ctrblocks[0]; 311 312 src += 1; 313 dst += 1; 314 } while ((nbytes -= bsize) >= bsize); 315 316 done: 317 *(__be64 *)walk->iv = cpu_to_be64(ctrblk); 318 return nbytes; 319 } 320 321 static int ctr_crypt(struct skcipher_request *req) 322 { 323 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 324 struct des3_ede_x86_ctx *ctx = crypto_skcipher_ctx(tfm); 325 struct skcipher_walk walk; 326 unsigned int nbytes; 327 int err; 328 329 err = skcipher_walk_virt(&walk, req, false); 330 331 while ((nbytes = walk.nbytes) >= DES3_EDE_BLOCK_SIZE) { 332 nbytes = __ctr_crypt(ctx, &walk); 333 err = skcipher_walk_done(&walk, nbytes); 334 } 335 336 if (nbytes) { 337 ctr_crypt_final(ctx, &walk); 338 err = skcipher_walk_done(&walk, 0); 339 } 340 341 return err; 342 } 343 344 static int des3_ede_x86_setkey(struct crypto_tfm *tfm, const u8 *key, 345 unsigned int keylen) 346 { 347 struct des3_ede_x86_ctx *ctx = crypto_tfm_ctx(tfm); 348 u32 i, j, tmp; 349 int err; 350 351 err = crypto_des3_ede_verify_key(tfm, key); 352 if (err) 353 return err; 354 355 /* Generate encryption context using generic implementation. */ 356 err = __des3_ede_setkey(ctx->enc_expkey, &tfm->crt_flags, key, keylen); 357 if (err < 0) 358 return err; 359 360 /* Fix encryption context for this implementation and form decryption 361 * context. */ 362 j = DES3_EDE_EXPKEY_WORDS - 2; 363 for (i = 0; i < DES3_EDE_EXPKEY_WORDS; i += 2, j -= 2) { 364 tmp = ror32(ctx->enc_expkey[i + 1], 4); 365 ctx->enc_expkey[i + 1] = tmp; 366 367 ctx->dec_expkey[j + 0] = ctx->enc_expkey[i + 0]; 368 ctx->dec_expkey[j + 1] = tmp; 369 } 370 371 return 0; 372 } 373 374 static int des3_ede_x86_setkey_skcipher(struct crypto_skcipher *tfm, 375 const u8 *key, 376 unsigned int keylen) 377 { 378 return des3_ede_x86_setkey(&tfm->base, key, keylen); 379 } 380 381 static struct crypto_alg des3_ede_cipher = { 382 .cra_name = "des3_ede", 383 .cra_driver_name = "des3_ede-asm", 384 .cra_priority = 200, 385 .cra_flags = CRYPTO_ALG_TYPE_CIPHER, 386 .cra_blocksize = DES3_EDE_BLOCK_SIZE, 387 .cra_ctxsize = sizeof(struct des3_ede_x86_ctx), 388 .cra_alignmask = 0, 389 .cra_module = THIS_MODULE, 390 .cra_u = { 391 .cipher = { 392 .cia_min_keysize = DES3_EDE_KEY_SIZE, 393 .cia_max_keysize = DES3_EDE_KEY_SIZE, 394 .cia_setkey = des3_ede_x86_setkey, 395 .cia_encrypt = des3_ede_x86_encrypt, 396 .cia_decrypt = des3_ede_x86_decrypt, 397 } 398 } 399 }; 400 401 static struct skcipher_alg des3_ede_skciphers[] = { 402 { 403 .base.cra_name = "ecb(des3_ede)", 404 .base.cra_driver_name = "ecb-des3_ede-asm", 405 .base.cra_priority = 300, 406 .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, 407 .base.cra_ctxsize = sizeof(struct des3_ede_x86_ctx), 408 .base.cra_module = THIS_MODULE, 409 .min_keysize = DES3_EDE_KEY_SIZE, 410 .max_keysize = DES3_EDE_KEY_SIZE, 411 .setkey = des3_ede_x86_setkey_skcipher, 412 .encrypt = ecb_encrypt, 413 .decrypt = ecb_decrypt, 414 }, { 415 .base.cra_name = "cbc(des3_ede)", 416 .base.cra_driver_name = "cbc-des3_ede-asm", 417 .base.cra_priority = 300, 418 .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, 419 .base.cra_ctxsize = sizeof(struct des3_ede_x86_ctx), 420 .base.cra_module = THIS_MODULE, 421 .min_keysize = DES3_EDE_KEY_SIZE, 422 .max_keysize = DES3_EDE_KEY_SIZE, 423 .ivsize = DES3_EDE_BLOCK_SIZE, 424 .setkey = des3_ede_x86_setkey_skcipher, 425 .encrypt = cbc_encrypt, 426 .decrypt = cbc_decrypt, 427 }, { 428 .base.cra_name = "ctr(des3_ede)", 429 .base.cra_driver_name = "ctr-des3_ede-asm", 430 .base.cra_priority = 300, 431 .base.cra_blocksize = 1, 432 .base.cra_ctxsize = sizeof(struct des3_ede_x86_ctx), 433 .base.cra_module = THIS_MODULE, 434 .min_keysize = DES3_EDE_KEY_SIZE, 435 .max_keysize = DES3_EDE_KEY_SIZE, 436 .ivsize = DES3_EDE_BLOCK_SIZE, 437 .chunksize = DES3_EDE_BLOCK_SIZE, 438 .setkey = des3_ede_x86_setkey_skcipher, 439 .encrypt = ctr_crypt, 440 .decrypt = ctr_crypt, 441 } 442 }; 443 444 static bool is_blacklisted_cpu(void) 445 { 446 if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) 447 return false; 448 449 if (boot_cpu_data.x86 == 0x0f) { 450 /* 451 * On Pentium 4, des3_ede-x86_64 is slower than generic C 452 * implementation because use of 64bit rotates (which are really 453 * slow on P4). Therefore blacklist P4s. 454 */ 455 return true; 456 } 457 458 return false; 459 } 460 461 static int force; 462 module_param(force, int, 0); 463 MODULE_PARM_DESC(force, "Force module load, ignore CPU blacklist"); 464 465 static int __init des3_ede_x86_init(void) 466 { 467 int err; 468 469 if (!force && is_blacklisted_cpu()) { 470 pr_info("des3_ede-x86_64: performance on this CPU would be suboptimal: disabling des3_ede-x86_64.\n"); 471 return -ENODEV; 472 } 473 474 err = crypto_register_alg(&des3_ede_cipher); 475 if (err) 476 return err; 477 478 err = crypto_register_skciphers(des3_ede_skciphers, 479 ARRAY_SIZE(des3_ede_skciphers)); 480 if (err) 481 crypto_unregister_alg(&des3_ede_cipher); 482 483 return err; 484 } 485 486 static void __exit des3_ede_x86_fini(void) 487 { 488 crypto_unregister_alg(&des3_ede_cipher); 489 crypto_unregister_skciphers(des3_ede_skciphers, 490 ARRAY_SIZE(des3_ede_skciphers)); 491 } 492 493 module_init(des3_ede_x86_init); 494 module_exit(des3_ede_x86_fini); 495 496 MODULE_LICENSE("GPL"); 497 MODULE_DESCRIPTION("Triple DES EDE Cipher Algorithm, asm optimized"); 498 MODULE_ALIAS_CRYPTO("des3_ede"); 499 MODULE_ALIAS_CRYPTO("des3_ede-asm"); 500 MODULE_AUTHOR("Jussi Kivilinna <jussi.kivilinna@iki.fi>"); 501