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