1 /* 2 * Cryptographic API. 3 * 4 * s390 implementation of the DES Cipher Algorithm. 5 * 6 * Copyright IBM Corp. 2003, 2011 7 * Author(s): Thomas Spatzier 8 * Jan Glauber (jan.glauber@de.ibm.com) 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 */ 16 17 #include <linux/init.h> 18 #include <linux/module.h> 19 #include <linux/cpufeature.h> 20 #include <linux/crypto.h> 21 #include <crypto/algapi.h> 22 #include <crypto/des.h> 23 #include <asm/cpacf.h> 24 25 #define DES3_KEY_SIZE (3 * DES_KEY_SIZE) 26 27 static u8 *ctrblk; 28 static DEFINE_SPINLOCK(ctrblk_lock); 29 30 struct s390_des_ctx { 31 u8 iv[DES_BLOCK_SIZE]; 32 u8 key[DES3_KEY_SIZE]; 33 }; 34 35 static int des_setkey(struct crypto_tfm *tfm, const u8 *key, 36 unsigned int key_len) 37 { 38 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 39 u32 *flags = &tfm->crt_flags; 40 u32 tmp[DES_EXPKEY_WORDS]; 41 42 /* check for weak keys */ 43 if (!des_ekey(tmp, key) && (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) { 44 *flags |= CRYPTO_TFM_RES_WEAK_KEY; 45 return -EINVAL; 46 } 47 48 memcpy(ctx->key, key, key_len); 49 return 0; 50 } 51 52 static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) 53 { 54 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 55 56 cpacf_km(CPACF_KM_DEA_ENC, ctx->key, out, in, DES_BLOCK_SIZE); 57 } 58 59 static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) 60 { 61 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 62 63 cpacf_km(CPACF_KM_DEA_DEC, ctx->key, out, in, DES_BLOCK_SIZE); 64 } 65 66 static struct crypto_alg des_alg = { 67 .cra_name = "des", 68 .cra_driver_name = "des-s390", 69 .cra_priority = 300, 70 .cra_flags = CRYPTO_ALG_TYPE_CIPHER, 71 .cra_blocksize = DES_BLOCK_SIZE, 72 .cra_ctxsize = sizeof(struct s390_des_ctx), 73 .cra_module = THIS_MODULE, 74 .cra_u = { 75 .cipher = { 76 .cia_min_keysize = DES_KEY_SIZE, 77 .cia_max_keysize = DES_KEY_SIZE, 78 .cia_setkey = des_setkey, 79 .cia_encrypt = des_encrypt, 80 .cia_decrypt = des_decrypt, 81 } 82 } 83 }; 84 85 static int ecb_desall_crypt(struct blkcipher_desc *desc, long func, 86 u8 *key, struct blkcipher_walk *walk) 87 { 88 int ret = blkcipher_walk_virt(desc, walk); 89 unsigned int nbytes; 90 91 while ((nbytes = walk->nbytes)) { 92 /* only use complete blocks */ 93 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1); 94 u8 *out = walk->dst.virt.addr; 95 u8 *in = walk->src.virt.addr; 96 97 ret = cpacf_km(func, key, out, in, n); 98 if (ret < 0 || ret != n) 99 return -EIO; 100 101 nbytes &= DES_BLOCK_SIZE - 1; 102 ret = blkcipher_walk_done(desc, walk, nbytes); 103 } 104 105 return ret; 106 } 107 108 static int cbc_desall_crypt(struct blkcipher_desc *desc, long func, 109 struct blkcipher_walk *walk) 110 { 111 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 112 int ret = blkcipher_walk_virt(desc, walk); 113 unsigned int nbytes = walk->nbytes; 114 struct { 115 u8 iv[DES_BLOCK_SIZE]; 116 u8 key[DES3_KEY_SIZE]; 117 } param; 118 119 if (!nbytes) 120 goto out; 121 122 memcpy(param.iv, walk->iv, DES_BLOCK_SIZE); 123 memcpy(param.key, ctx->key, DES3_KEY_SIZE); 124 do { 125 /* only use complete blocks */ 126 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1); 127 u8 *out = walk->dst.virt.addr; 128 u8 *in = walk->src.virt.addr; 129 130 ret = cpacf_kmc(func, ¶m, out, in, n); 131 if (ret < 0 || ret != n) 132 return -EIO; 133 134 nbytes &= DES_BLOCK_SIZE - 1; 135 ret = blkcipher_walk_done(desc, walk, nbytes); 136 } while ((nbytes = walk->nbytes)); 137 memcpy(walk->iv, param.iv, DES_BLOCK_SIZE); 138 139 out: 140 return ret; 141 } 142 143 static int ecb_des_encrypt(struct blkcipher_desc *desc, 144 struct scatterlist *dst, struct scatterlist *src, 145 unsigned int nbytes) 146 { 147 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 148 struct blkcipher_walk walk; 149 150 blkcipher_walk_init(&walk, dst, src, nbytes); 151 return ecb_desall_crypt(desc, CPACF_KM_DEA_ENC, ctx->key, &walk); 152 } 153 154 static int ecb_des_decrypt(struct blkcipher_desc *desc, 155 struct scatterlist *dst, struct scatterlist *src, 156 unsigned int nbytes) 157 { 158 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 159 struct blkcipher_walk walk; 160 161 blkcipher_walk_init(&walk, dst, src, nbytes); 162 return ecb_desall_crypt(desc, CPACF_KM_DEA_DEC, ctx->key, &walk); 163 } 164 165 static struct crypto_alg ecb_des_alg = { 166 .cra_name = "ecb(des)", 167 .cra_driver_name = "ecb-des-s390", 168 .cra_priority = 400, /* combo: des + ecb */ 169 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 170 .cra_blocksize = DES_BLOCK_SIZE, 171 .cra_ctxsize = sizeof(struct s390_des_ctx), 172 .cra_type = &crypto_blkcipher_type, 173 .cra_module = THIS_MODULE, 174 .cra_u = { 175 .blkcipher = { 176 .min_keysize = DES_KEY_SIZE, 177 .max_keysize = DES_KEY_SIZE, 178 .setkey = des_setkey, 179 .encrypt = ecb_des_encrypt, 180 .decrypt = ecb_des_decrypt, 181 } 182 } 183 }; 184 185 static int cbc_des_encrypt(struct blkcipher_desc *desc, 186 struct scatterlist *dst, struct scatterlist *src, 187 unsigned int nbytes) 188 { 189 struct blkcipher_walk walk; 190 191 blkcipher_walk_init(&walk, dst, src, nbytes); 192 return cbc_desall_crypt(desc, CPACF_KMC_DEA_ENC, &walk); 193 } 194 195 static int cbc_des_decrypt(struct blkcipher_desc *desc, 196 struct scatterlist *dst, struct scatterlist *src, 197 unsigned int nbytes) 198 { 199 struct blkcipher_walk walk; 200 201 blkcipher_walk_init(&walk, dst, src, nbytes); 202 return cbc_desall_crypt(desc, CPACF_KMC_DEA_DEC, &walk); 203 } 204 205 static struct crypto_alg cbc_des_alg = { 206 .cra_name = "cbc(des)", 207 .cra_driver_name = "cbc-des-s390", 208 .cra_priority = 400, /* combo: des + cbc */ 209 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 210 .cra_blocksize = DES_BLOCK_SIZE, 211 .cra_ctxsize = sizeof(struct s390_des_ctx), 212 .cra_type = &crypto_blkcipher_type, 213 .cra_module = THIS_MODULE, 214 .cra_u = { 215 .blkcipher = { 216 .min_keysize = DES_KEY_SIZE, 217 .max_keysize = DES_KEY_SIZE, 218 .ivsize = DES_BLOCK_SIZE, 219 .setkey = des_setkey, 220 .encrypt = cbc_des_encrypt, 221 .decrypt = cbc_des_decrypt, 222 } 223 } 224 }; 225 226 /* 227 * RFC2451: 228 * 229 * For DES-EDE3, there is no known need to reject weak or 230 * complementation keys. Any weakness is obviated by the use of 231 * multiple keys. 232 * 233 * However, if the first two or last two independent 64-bit keys are 234 * equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the 235 * same as DES. Implementers MUST reject keys that exhibit this 236 * property. 237 * 238 */ 239 static int des3_setkey(struct crypto_tfm *tfm, const u8 *key, 240 unsigned int key_len) 241 { 242 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 243 u32 *flags = &tfm->crt_flags; 244 245 if (!(crypto_memneq(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) && 246 crypto_memneq(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2], 247 DES_KEY_SIZE)) && 248 (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) { 249 *flags |= CRYPTO_TFM_RES_WEAK_KEY; 250 return -EINVAL; 251 } 252 memcpy(ctx->key, key, key_len); 253 return 0; 254 } 255 256 static void des3_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 257 { 258 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 259 260 cpacf_km(CPACF_KM_TDEA_192_ENC, ctx->key, dst, src, DES_BLOCK_SIZE); 261 } 262 263 static void des3_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 264 { 265 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 266 267 cpacf_km(CPACF_KM_TDEA_192_DEC, ctx->key, dst, src, DES_BLOCK_SIZE); 268 } 269 270 static struct crypto_alg des3_alg = { 271 .cra_name = "des3_ede", 272 .cra_driver_name = "des3_ede-s390", 273 .cra_priority = 300, 274 .cra_flags = CRYPTO_ALG_TYPE_CIPHER, 275 .cra_blocksize = DES_BLOCK_SIZE, 276 .cra_ctxsize = sizeof(struct s390_des_ctx), 277 .cra_module = THIS_MODULE, 278 .cra_u = { 279 .cipher = { 280 .cia_min_keysize = DES3_KEY_SIZE, 281 .cia_max_keysize = DES3_KEY_SIZE, 282 .cia_setkey = des3_setkey, 283 .cia_encrypt = des3_encrypt, 284 .cia_decrypt = des3_decrypt, 285 } 286 } 287 }; 288 289 static int ecb_des3_encrypt(struct blkcipher_desc *desc, 290 struct scatterlist *dst, struct scatterlist *src, 291 unsigned int nbytes) 292 { 293 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 294 struct blkcipher_walk walk; 295 296 blkcipher_walk_init(&walk, dst, src, nbytes); 297 return ecb_desall_crypt(desc, CPACF_KM_TDEA_192_ENC, ctx->key, &walk); 298 } 299 300 static int ecb_des3_decrypt(struct blkcipher_desc *desc, 301 struct scatterlist *dst, struct scatterlist *src, 302 unsigned int nbytes) 303 { 304 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 305 struct blkcipher_walk walk; 306 307 blkcipher_walk_init(&walk, dst, src, nbytes); 308 return ecb_desall_crypt(desc, CPACF_KM_TDEA_192_DEC, ctx->key, &walk); 309 } 310 311 static struct crypto_alg ecb_des3_alg = { 312 .cra_name = "ecb(des3_ede)", 313 .cra_driver_name = "ecb-des3_ede-s390", 314 .cra_priority = 400, /* combo: des3 + ecb */ 315 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 316 .cra_blocksize = DES_BLOCK_SIZE, 317 .cra_ctxsize = sizeof(struct s390_des_ctx), 318 .cra_type = &crypto_blkcipher_type, 319 .cra_module = THIS_MODULE, 320 .cra_u = { 321 .blkcipher = { 322 .min_keysize = DES3_KEY_SIZE, 323 .max_keysize = DES3_KEY_SIZE, 324 .setkey = des3_setkey, 325 .encrypt = ecb_des3_encrypt, 326 .decrypt = ecb_des3_decrypt, 327 } 328 } 329 }; 330 331 static int cbc_des3_encrypt(struct blkcipher_desc *desc, 332 struct scatterlist *dst, struct scatterlist *src, 333 unsigned int nbytes) 334 { 335 struct blkcipher_walk walk; 336 337 blkcipher_walk_init(&walk, dst, src, nbytes); 338 return cbc_desall_crypt(desc, CPACF_KMC_TDEA_192_ENC, &walk); 339 } 340 341 static int cbc_des3_decrypt(struct blkcipher_desc *desc, 342 struct scatterlist *dst, struct scatterlist *src, 343 unsigned int nbytes) 344 { 345 struct blkcipher_walk walk; 346 347 blkcipher_walk_init(&walk, dst, src, nbytes); 348 return cbc_desall_crypt(desc, CPACF_KMC_TDEA_192_DEC, &walk); 349 } 350 351 static struct crypto_alg cbc_des3_alg = { 352 .cra_name = "cbc(des3_ede)", 353 .cra_driver_name = "cbc-des3_ede-s390", 354 .cra_priority = 400, /* combo: des3 + cbc */ 355 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 356 .cra_blocksize = DES_BLOCK_SIZE, 357 .cra_ctxsize = sizeof(struct s390_des_ctx), 358 .cra_type = &crypto_blkcipher_type, 359 .cra_module = THIS_MODULE, 360 .cra_u = { 361 .blkcipher = { 362 .min_keysize = DES3_KEY_SIZE, 363 .max_keysize = DES3_KEY_SIZE, 364 .ivsize = DES_BLOCK_SIZE, 365 .setkey = des3_setkey, 366 .encrypt = cbc_des3_encrypt, 367 .decrypt = cbc_des3_decrypt, 368 } 369 } 370 }; 371 372 static unsigned int __ctrblk_init(u8 *ctrptr, unsigned int nbytes) 373 { 374 unsigned int i, n; 375 376 /* align to block size, max. PAGE_SIZE */ 377 n = (nbytes > PAGE_SIZE) ? PAGE_SIZE : nbytes & ~(DES_BLOCK_SIZE - 1); 378 for (i = DES_BLOCK_SIZE; i < n; i += DES_BLOCK_SIZE) { 379 memcpy(ctrptr + i, ctrptr + i - DES_BLOCK_SIZE, DES_BLOCK_SIZE); 380 crypto_inc(ctrptr + i, DES_BLOCK_SIZE); 381 } 382 return n; 383 } 384 385 static int ctr_desall_crypt(struct blkcipher_desc *desc, long func, 386 struct s390_des_ctx *ctx, 387 struct blkcipher_walk *walk) 388 { 389 int ret = blkcipher_walk_virt_block(desc, walk, DES_BLOCK_SIZE); 390 unsigned int n, nbytes; 391 u8 buf[DES_BLOCK_SIZE], ctrbuf[DES_BLOCK_SIZE]; 392 u8 *out, *in, *ctrptr = ctrbuf; 393 394 if (!walk->nbytes) 395 return ret; 396 397 if (spin_trylock(&ctrblk_lock)) 398 ctrptr = ctrblk; 399 400 memcpy(ctrptr, walk->iv, DES_BLOCK_SIZE); 401 while ((nbytes = walk->nbytes) >= DES_BLOCK_SIZE) { 402 out = walk->dst.virt.addr; 403 in = walk->src.virt.addr; 404 while (nbytes >= DES_BLOCK_SIZE) { 405 if (ctrptr == ctrblk) 406 n = __ctrblk_init(ctrptr, nbytes); 407 else 408 n = DES_BLOCK_SIZE; 409 ret = cpacf_kmctr(func, ctx->key, out, in, n, ctrptr); 410 if (ret < 0 || ret != n) { 411 if (ctrptr == ctrblk) 412 spin_unlock(&ctrblk_lock); 413 return -EIO; 414 } 415 if (n > DES_BLOCK_SIZE) 416 memcpy(ctrptr, ctrptr + n - DES_BLOCK_SIZE, 417 DES_BLOCK_SIZE); 418 crypto_inc(ctrptr, DES_BLOCK_SIZE); 419 out += n; 420 in += n; 421 nbytes -= n; 422 } 423 ret = blkcipher_walk_done(desc, walk, nbytes); 424 } 425 if (ctrptr == ctrblk) { 426 if (nbytes) 427 memcpy(ctrbuf, ctrptr, DES_BLOCK_SIZE); 428 else 429 memcpy(walk->iv, ctrptr, DES_BLOCK_SIZE); 430 spin_unlock(&ctrblk_lock); 431 } else { 432 if (!nbytes) 433 memcpy(walk->iv, ctrptr, DES_BLOCK_SIZE); 434 } 435 /* final block may be < DES_BLOCK_SIZE, copy only nbytes */ 436 if (nbytes) { 437 out = walk->dst.virt.addr; 438 in = walk->src.virt.addr; 439 ret = cpacf_kmctr(func, ctx->key, buf, in, 440 DES_BLOCK_SIZE, ctrbuf); 441 if (ret < 0 || ret != DES_BLOCK_SIZE) 442 return -EIO; 443 memcpy(out, buf, nbytes); 444 crypto_inc(ctrbuf, DES_BLOCK_SIZE); 445 ret = blkcipher_walk_done(desc, walk, 0); 446 memcpy(walk->iv, ctrbuf, DES_BLOCK_SIZE); 447 } 448 return ret; 449 } 450 451 static int ctr_des_encrypt(struct blkcipher_desc *desc, 452 struct scatterlist *dst, struct scatterlist *src, 453 unsigned int nbytes) 454 { 455 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 456 struct blkcipher_walk walk; 457 458 blkcipher_walk_init(&walk, dst, src, nbytes); 459 return ctr_desall_crypt(desc, CPACF_KMCTR_DEA_ENC, ctx, &walk); 460 } 461 462 static int ctr_des_decrypt(struct blkcipher_desc *desc, 463 struct scatterlist *dst, struct scatterlist *src, 464 unsigned int nbytes) 465 { 466 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 467 struct blkcipher_walk walk; 468 469 blkcipher_walk_init(&walk, dst, src, nbytes); 470 return ctr_desall_crypt(desc, CPACF_KMCTR_DEA_DEC, ctx, &walk); 471 } 472 473 static struct crypto_alg ctr_des_alg = { 474 .cra_name = "ctr(des)", 475 .cra_driver_name = "ctr-des-s390", 476 .cra_priority = 400, /* combo: des + ctr */ 477 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 478 .cra_blocksize = 1, 479 .cra_ctxsize = sizeof(struct s390_des_ctx), 480 .cra_type = &crypto_blkcipher_type, 481 .cra_module = THIS_MODULE, 482 .cra_u = { 483 .blkcipher = { 484 .min_keysize = DES_KEY_SIZE, 485 .max_keysize = DES_KEY_SIZE, 486 .ivsize = DES_BLOCK_SIZE, 487 .setkey = des_setkey, 488 .encrypt = ctr_des_encrypt, 489 .decrypt = ctr_des_decrypt, 490 } 491 } 492 }; 493 494 static int ctr_des3_encrypt(struct blkcipher_desc *desc, 495 struct scatterlist *dst, struct scatterlist *src, 496 unsigned int nbytes) 497 { 498 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 499 struct blkcipher_walk walk; 500 501 blkcipher_walk_init(&walk, dst, src, nbytes); 502 return ctr_desall_crypt(desc, CPACF_KMCTR_TDEA_192_ENC, ctx, &walk); 503 } 504 505 static int ctr_des3_decrypt(struct blkcipher_desc *desc, 506 struct scatterlist *dst, struct scatterlist *src, 507 unsigned int nbytes) 508 { 509 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 510 struct blkcipher_walk walk; 511 512 blkcipher_walk_init(&walk, dst, src, nbytes); 513 return ctr_desall_crypt(desc, CPACF_KMCTR_TDEA_192_DEC, ctx, &walk); 514 } 515 516 static struct crypto_alg ctr_des3_alg = { 517 .cra_name = "ctr(des3_ede)", 518 .cra_driver_name = "ctr-des3_ede-s390", 519 .cra_priority = 400, /* combo: des3 + ede */ 520 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 521 .cra_blocksize = 1, 522 .cra_ctxsize = sizeof(struct s390_des_ctx), 523 .cra_type = &crypto_blkcipher_type, 524 .cra_module = THIS_MODULE, 525 .cra_u = { 526 .blkcipher = { 527 .min_keysize = DES3_KEY_SIZE, 528 .max_keysize = DES3_KEY_SIZE, 529 .ivsize = DES_BLOCK_SIZE, 530 .setkey = des3_setkey, 531 .encrypt = ctr_des3_encrypt, 532 .decrypt = ctr_des3_decrypt, 533 } 534 } 535 }; 536 537 static int __init des_s390_init(void) 538 { 539 int ret; 540 541 if (!cpacf_query(CPACF_KM, CPACF_KM_DEA_ENC) || 542 !cpacf_query(CPACF_KM, CPACF_KM_TDEA_192_ENC)) 543 return -EOPNOTSUPP; 544 545 ret = crypto_register_alg(&des_alg); 546 if (ret) 547 goto des_err; 548 ret = crypto_register_alg(&ecb_des_alg); 549 if (ret) 550 goto ecb_des_err; 551 ret = crypto_register_alg(&cbc_des_alg); 552 if (ret) 553 goto cbc_des_err; 554 ret = crypto_register_alg(&des3_alg); 555 if (ret) 556 goto des3_err; 557 ret = crypto_register_alg(&ecb_des3_alg); 558 if (ret) 559 goto ecb_des3_err; 560 ret = crypto_register_alg(&cbc_des3_alg); 561 if (ret) 562 goto cbc_des3_err; 563 564 if (cpacf_query(CPACF_KMCTR, CPACF_KMCTR_DEA_ENC) && 565 cpacf_query(CPACF_KMCTR, CPACF_KMCTR_TDEA_192_ENC)) { 566 ret = crypto_register_alg(&ctr_des_alg); 567 if (ret) 568 goto ctr_des_err; 569 ret = crypto_register_alg(&ctr_des3_alg); 570 if (ret) 571 goto ctr_des3_err; 572 ctrblk = (u8 *) __get_free_page(GFP_KERNEL); 573 if (!ctrblk) { 574 ret = -ENOMEM; 575 goto ctr_mem_err; 576 } 577 } 578 out: 579 return ret; 580 581 ctr_mem_err: 582 crypto_unregister_alg(&ctr_des3_alg); 583 ctr_des3_err: 584 crypto_unregister_alg(&ctr_des_alg); 585 ctr_des_err: 586 crypto_unregister_alg(&cbc_des3_alg); 587 cbc_des3_err: 588 crypto_unregister_alg(&ecb_des3_alg); 589 ecb_des3_err: 590 crypto_unregister_alg(&des3_alg); 591 des3_err: 592 crypto_unregister_alg(&cbc_des_alg); 593 cbc_des_err: 594 crypto_unregister_alg(&ecb_des_alg); 595 ecb_des_err: 596 crypto_unregister_alg(&des_alg); 597 des_err: 598 goto out; 599 } 600 601 static void __exit des_s390_exit(void) 602 { 603 if (ctrblk) { 604 crypto_unregister_alg(&ctr_des_alg); 605 crypto_unregister_alg(&ctr_des3_alg); 606 free_page((unsigned long) ctrblk); 607 } 608 crypto_unregister_alg(&cbc_des3_alg); 609 crypto_unregister_alg(&ecb_des3_alg); 610 crypto_unregister_alg(&des3_alg); 611 crypto_unregister_alg(&cbc_des_alg); 612 crypto_unregister_alg(&ecb_des_alg); 613 crypto_unregister_alg(&des_alg); 614 } 615 616 module_cpu_feature_match(MSA, des_s390_init); 617 module_exit(des_s390_exit); 618 619 MODULE_ALIAS_CRYPTO("des"); 620 MODULE_ALIAS_CRYPTO("des3_ede"); 621 622 MODULE_LICENSE("GPL"); 623 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms"); 624