1 /* 2 * Cryptographic API. 3 * 4 * s390 implementation of the DES Cipher Algorithm. 5 * 6 * Copyright IBM Corp. 2003,2007 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 <crypto/algapi.h> 18 #include <linux/init.h> 19 #include <linux/module.h> 20 21 #include "crypt_s390.h" 22 #include "crypto_des.h" 23 24 #define DES_BLOCK_SIZE 8 25 #define DES_KEY_SIZE 8 26 27 #define DES3_128_KEY_SIZE (2 * DES_KEY_SIZE) 28 #define DES3_128_BLOCK_SIZE DES_BLOCK_SIZE 29 30 #define DES3_192_KEY_SIZE (3 * DES_KEY_SIZE) 31 #define DES3_192_BLOCK_SIZE DES_BLOCK_SIZE 32 33 struct crypt_s390_des_ctx { 34 u8 iv[DES_BLOCK_SIZE]; 35 u8 key[DES_KEY_SIZE]; 36 }; 37 38 struct crypt_s390_des3_128_ctx { 39 u8 iv[DES_BLOCK_SIZE]; 40 u8 key[DES3_128_KEY_SIZE]; 41 }; 42 43 struct crypt_s390_des3_192_ctx { 44 u8 iv[DES_BLOCK_SIZE]; 45 u8 key[DES3_192_KEY_SIZE]; 46 }; 47 48 static int des_setkey(struct crypto_tfm *tfm, const u8 *key, 49 unsigned int keylen) 50 { 51 struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm); 52 u32 *flags = &tfm->crt_flags; 53 int ret; 54 55 /* test if key is valid (not a weak key) */ 56 ret = crypto_des_check_key(key, keylen, flags); 57 if (ret == 0) 58 memcpy(dctx->key, key, keylen); 59 return ret; 60 } 61 62 static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) 63 { 64 struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm); 65 66 crypt_s390_km(KM_DEA_ENCRYPT, dctx->key, out, in, DES_BLOCK_SIZE); 67 } 68 69 static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) 70 { 71 struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm); 72 73 crypt_s390_km(KM_DEA_DECRYPT, dctx->key, out, in, DES_BLOCK_SIZE); 74 } 75 76 static struct crypto_alg des_alg = { 77 .cra_name = "des", 78 .cra_driver_name = "des-s390", 79 .cra_priority = CRYPT_S390_PRIORITY, 80 .cra_flags = CRYPTO_ALG_TYPE_CIPHER, 81 .cra_blocksize = DES_BLOCK_SIZE, 82 .cra_ctxsize = sizeof(struct crypt_s390_des_ctx), 83 .cra_module = THIS_MODULE, 84 .cra_list = LIST_HEAD_INIT(des_alg.cra_list), 85 .cra_u = { 86 .cipher = { 87 .cia_min_keysize = DES_KEY_SIZE, 88 .cia_max_keysize = DES_KEY_SIZE, 89 .cia_setkey = des_setkey, 90 .cia_encrypt = des_encrypt, 91 .cia_decrypt = des_decrypt, 92 } 93 } 94 }; 95 96 static int ecb_desall_crypt(struct blkcipher_desc *desc, long func, 97 void *param, struct blkcipher_walk *walk) 98 { 99 int ret = blkcipher_walk_virt(desc, walk); 100 unsigned int nbytes; 101 102 while ((nbytes = walk->nbytes)) { 103 /* only use complete blocks */ 104 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1); 105 u8 *out = walk->dst.virt.addr; 106 u8 *in = walk->src.virt.addr; 107 108 ret = crypt_s390_km(func, param, out, in, n); 109 BUG_ON((ret < 0) || (ret != n)); 110 111 nbytes &= DES_BLOCK_SIZE - 1; 112 ret = blkcipher_walk_done(desc, walk, nbytes); 113 } 114 115 return ret; 116 } 117 118 static int cbc_desall_crypt(struct blkcipher_desc *desc, long func, 119 void *param, struct blkcipher_walk *walk) 120 { 121 int ret = blkcipher_walk_virt(desc, walk); 122 unsigned int nbytes = walk->nbytes; 123 124 if (!nbytes) 125 goto out; 126 127 memcpy(param, walk->iv, DES_BLOCK_SIZE); 128 do { 129 /* only use complete blocks */ 130 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1); 131 u8 *out = walk->dst.virt.addr; 132 u8 *in = walk->src.virt.addr; 133 134 ret = crypt_s390_kmc(func, param, out, in, n); 135 BUG_ON((ret < 0) || (ret != n)); 136 137 nbytes &= DES_BLOCK_SIZE - 1; 138 ret = blkcipher_walk_done(desc, walk, nbytes); 139 } while ((nbytes = walk->nbytes)); 140 memcpy(walk->iv, param, DES_BLOCK_SIZE); 141 142 out: 143 return ret; 144 } 145 146 static int ecb_des_encrypt(struct blkcipher_desc *desc, 147 struct scatterlist *dst, struct scatterlist *src, 148 unsigned int nbytes) 149 { 150 struct crypt_s390_des_ctx *sctx = 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_ENCRYPT, sctx->key, &walk); 155 } 156 157 static int ecb_des_decrypt(struct blkcipher_desc *desc, 158 struct scatterlist *dst, struct scatterlist *src, 159 unsigned int nbytes) 160 { 161 struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 162 struct blkcipher_walk walk; 163 164 blkcipher_walk_init(&walk, dst, src, nbytes); 165 return ecb_desall_crypt(desc, KM_DEA_DECRYPT, sctx->key, &walk); 166 } 167 168 static struct crypto_alg ecb_des_alg = { 169 .cra_name = "ecb(des)", 170 .cra_driver_name = "ecb-des-s390", 171 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 172 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 173 .cra_blocksize = DES_BLOCK_SIZE, 174 .cra_ctxsize = sizeof(struct crypt_s390_des_ctx), 175 .cra_type = &crypto_blkcipher_type, 176 .cra_module = THIS_MODULE, 177 .cra_list = LIST_HEAD_INIT(ecb_des_alg.cra_list), 178 .cra_u = { 179 .blkcipher = { 180 .min_keysize = DES_KEY_SIZE, 181 .max_keysize = DES_KEY_SIZE, 182 .setkey = des_setkey, 183 .encrypt = ecb_des_encrypt, 184 .decrypt = ecb_des_decrypt, 185 } 186 } 187 }; 188 189 static int cbc_des_encrypt(struct blkcipher_desc *desc, 190 struct scatterlist *dst, struct scatterlist *src, 191 unsigned int nbytes) 192 { 193 struct crypt_s390_des_ctx *sctx = 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_ENCRYPT, sctx->iv, &walk); 198 } 199 200 static int cbc_des_decrypt(struct blkcipher_desc *desc, 201 struct scatterlist *dst, struct scatterlist *src, 202 unsigned int nbytes) 203 { 204 struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 205 struct blkcipher_walk walk; 206 207 blkcipher_walk_init(&walk, dst, src, nbytes); 208 return cbc_desall_crypt(desc, KMC_DEA_DECRYPT, sctx->iv, &walk); 209 } 210 211 static struct crypto_alg cbc_des_alg = { 212 .cra_name = "cbc(des)", 213 .cra_driver_name = "cbc-des-s390", 214 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 215 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 216 .cra_blocksize = DES_BLOCK_SIZE, 217 .cra_ctxsize = sizeof(struct crypt_s390_des_ctx), 218 .cra_type = &crypto_blkcipher_type, 219 .cra_module = THIS_MODULE, 220 .cra_list = LIST_HEAD_INIT(cbc_des_alg.cra_list), 221 .cra_u = { 222 .blkcipher = { 223 .min_keysize = DES_KEY_SIZE, 224 .max_keysize = DES_KEY_SIZE, 225 .ivsize = DES_BLOCK_SIZE, 226 .setkey = des_setkey, 227 .encrypt = cbc_des_encrypt, 228 .decrypt = cbc_des_decrypt, 229 } 230 } 231 }; 232 233 /* 234 * RFC2451: 235 * 236 * For DES-EDE3, there is no known need to reject weak or 237 * complementation keys. Any weakness is obviated by the use of 238 * multiple keys. 239 * 240 * However, if the two independent 64-bit keys are equal, 241 * then the DES3 operation is simply the same as DES. 242 * Implementers MUST reject keys that exhibit this property. 243 * 244 */ 245 static int des3_128_setkey(struct crypto_tfm *tfm, const u8 *key, 246 unsigned int keylen) 247 { 248 int i, ret; 249 struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm); 250 const u8 *temp_key = key; 251 u32 *flags = &tfm->crt_flags; 252 253 if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE))) { 254 *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED; 255 return -EINVAL; 256 } 257 for (i = 0; i < 2; i++, temp_key += DES_KEY_SIZE) { 258 ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags); 259 if (ret < 0) 260 return ret; 261 } 262 memcpy(dctx->key, key, keylen); 263 return 0; 264 } 265 266 static void des3_128_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 267 { 268 struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm); 269 270 crypt_s390_km(KM_TDEA_128_ENCRYPT, dctx->key, dst, (void*)src, 271 DES3_128_BLOCK_SIZE); 272 } 273 274 static void des3_128_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 275 { 276 struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm); 277 278 crypt_s390_km(KM_TDEA_128_DECRYPT, dctx->key, dst, (void*)src, 279 DES3_128_BLOCK_SIZE); 280 } 281 282 static struct crypto_alg des3_128_alg = { 283 .cra_name = "des3_ede128", 284 .cra_driver_name = "des3_ede128-s390", 285 .cra_priority = CRYPT_S390_PRIORITY, 286 .cra_flags = CRYPTO_ALG_TYPE_CIPHER, 287 .cra_blocksize = DES3_128_BLOCK_SIZE, 288 .cra_ctxsize = sizeof(struct crypt_s390_des3_128_ctx), 289 .cra_module = THIS_MODULE, 290 .cra_list = LIST_HEAD_INIT(des3_128_alg.cra_list), 291 .cra_u = { 292 .cipher = { 293 .cia_min_keysize = DES3_128_KEY_SIZE, 294 .cia_max_keysize = DES3_128_KEY_SIZE, 295 .cia_setkey = des3_128_setkey, 296 .cia_encrypt = des3_128_encrypt, 297 .cia_decrypt = des3_128_decrypt, 298 } 299 } 300 }; 301 302 static int ecb_des3_128_encrypt(struct blkcipher_desc *desc, 303 struct scatterlist *dst, 304 struct scatterlist *src, unsigned int nbytes) 305 { 306 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 307 struct blkcipher_walk walk; 308 309 blkcipher_walk_init(&walk, dst, src, nbytes); 310 return ecb_desall_crypt(desc, KM_TDEA_128_ENCRYPT, sctx->key, &walk); 311 } 312 313 static int ecb_des3_128_decrypt(struct blkcipher_desc *desc, 314 struct scatterlist *dst, 315 struct scatterlist *src, unsigned int nbytes) 316 { 317 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 318 struct blkcipher_walk walk; 319 320 blkcipher_walk_init(&walk, dst, src, nbytes); 321 return ecb_desall_crypt(desc, KM_TDEA_128_DECRYPT, sctx->key, &walk); 322 } 323 324 static struct crypto_alg ecb_des3_128_alg = { 325 .cra_name = "ecb(des3_ede128)", 326 .cra_driver_name = "ecb-des3_ede128-s390", 327 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 328 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 329 .cra_blocksize = DES3_128_BLOCK_SIZE, 330 .cra_ctxsize = sizeof(struct crypt_s390_des3_128_ctx), 331 .cra_type = &crypto_blkcipher_type, 332 .cra_module = THIS_MODULE, 333 .cra_list = LIST_HEAD_INIT( 334 ecb_des3_128_alg.cra_list), 335 .cra_u = { 336 .blkcipher = { 337 .min_keysize = DES3_128_KEY_SIZE, 338 .max_keysize = DES3_128_KEY_SIZE, 339 .setkey = des3_128_setkey, 340 .encrypt = ecb_des3_128_encrypt, 341 .decrypt = ecb_des3_128_decrypt, 342 } 343 } 344 }; 345 346 static int cbc_des3_128_encrypt(struct blkcipher_desc *desc, 347 struct scatterlist *dst, 348 struct scatterlist *src, unsigned int nbytes) 349 { 350 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 351 struct blkcipher_walk walk; 352 353 blkcipher_walk_init(&walk, dst, src, nbytes); 354 return cbc_desall_crypt(desc, KMC_TDEA_128_ENCRYPT, sctx->iv, &walk); 355 } 356 357 static int cbc_des3_128_decrypt(struct blkcipher_desc *desc, 358 struct scatterlist *dst, 359 struct scatterlist *src, unsigned int nbytes) 360 { 361 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 362 struct blkcipher_walk walk; 363 364 blkcipher_walk_init(&walk, dst, src, nbytes); 365 return cbc_desall_crypt(desc, KMC_TDEA_128_DECRYPT, sctx->iv, &walk); 366 } 367 368 static struct crypto_alg cbc_des3_128_alg = { 369 .cra_name = "cbc(des3_ede128)", 370 .cra_driver_name = "cbc-des3_ede128-s390", 371 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 372 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 373 .cra_blocksize = DES3_128_BLOCK_SIZE, 374 .cra_ctxsize = sizeof(struct crypt_s390_des3_128_ctx), 375 .cra_type = &crypto_blkcipher_type, 376 .cra_module = THIS_MODULE, 377 .cra_list = LIST_HEAD_INIT( 378 cbc_des3_128_alg.cra_list), 379 .cra_u = { 380 .blkcipher = { 381 .min_keysize = DES3_128_KEY_SIZE, 382 .max_keysize = DES3_128_KEY_SIZE, 383 .ivsize = DES3_128_BLOCK_SIZE, 384 .setkey = des3_128_setkey, 385 .encrypt = cbc_des3_128_encrypt, 386 .decrypt = cbc_des3_128_decrypt, 387 } 388 } 389 }; 390 391 /* 392 * RFC2451: 393 * 394 * For DES-EDE3, there is no known need to reject weak or 395 * complementation keys. Any weakness is obviated by the use of 396 * multiple keys. 397 * 398 * However, if the first two or last two independent 64-bit keys are 399 * equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the 400 * same as DES. Implementers MUST reject keys that exhibit this 401 * property. 402 * 403 */ 404 static int des3_192_setkey(struct crypto_tfm *tfm, const u8 *key, 405 unsigned int keylen) 406 { 407 int i, ret; 408 struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm); 409 const u8 *temp_key = key; 410 u32 *flags = &tfm->crt_flags; 411 412 if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) && 413 memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2], 414 DES_KEY_SIZE))) { 415 416 *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED; 417 return -EINVAL; 418 } 419 for (i = 0; i < 3; i++, temp_key += DES_KEY_SIZE) { 420 ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags); 421 if (ret < 0) 422 return ret; 423 } 424 memcpy(dctx->key, key, keylen); 425 return 0; 426 } 427 428 static void des3_192_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 429 { 430 struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm); 431 432 crypt_s390_km(KM_TDEA_192_ENCRYPT, dctx->key, dst, (void*)src, 433 DES3_192_BLOCK_SIZE); 434 } 435 436 static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 437 { 438 struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm); 439 440 crypt_s390_km(KM_TDEA_192_DECRYPT, dctx->key, dst, (void*)src, 441 DES3_192_BLOCK_SIZE); 442 } 443 444 static struct crypto_alg des3_192_alg = { 445 .cra_name = "des3_ede", 446 .cra_driver_name = "des3_ede-s390", 447 .cra_priority = CRYPT_S390_PRIORITY, 448 .cra_flags = CRYPTO_ALG_TYPE_CIPHER, 449 .cra_blocksize = DES3_192_BLOCK_SIZE, 450 .cra_ctxsize = sizeof(struct crypt_s390_des3_192_ctx), 451 .cra_module = THIS_MODULE, 452 .cra_list = LIST_HEAD_INIT(des3_192_alg.cra_list), 453 .cra_u = { 454 .cipher = { 455 .cia_min_keysize = DES3_192_KEY_SIZE, 456 .cia_max_keysize = DES3_192_KEY_SIZE, 457 .cia_setkey = des3_192_setkey, 458 .cia_encrypt = des3_192_encrypt, 459 .cia_decrypt = des3_192_decrypt, 460 } 461 } 462 }; 463 464 static int ecb_des3_192_encrypt(struct blkcipher_desc *desc, 465 struct scatterlist *dst, 466 struct scatterlist *src, unsigned int nbytes) 467 { 468 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 469 struct blkcipher_walk walk; 470 471 blkcipher_walk_init(&walk, dst, src, nbytes); 472 return ecb_desall_crypt(desc, KM_TDEA_192_ENCRYPT, sctx->key, &walk); 473 } 474 475 static int ecb_des3_192_decrypt(struct blkcipher_desc *desc, 476 struct scatterlist *dst, 477 struct scatterlist *src, unsigned int nbytes) 478 { 479 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 480 struct blkcipher_walk walk; 481 482 blkcipher_walk_init(&walk, dst, src, nbytes); 483 return ecb_desall_crypt(desc, KM_TDEA_192_DECRYPT, sctx->key, &walk); 484 } 485 486 static struct crypto_alg ecb_des3_192_alg = { 487 .cra_name = "ecb(des3_ede)", 488 .cra_driver_name = "ecb-des3_ede-s390", 489 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 490 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 491 .cra_blocksize = DES3_192_BLOCK_SIZE, 492 .cra_ctxsize = sizeof(struct crypt_s390_des3_192_ctx), 493 .cra_type = &crypto_blkcipher_type, 494 .cra_module = THIS_MODULE, 495 .cra_list = LIST_HEAD_INIT( 496 ecb_des3_192_alg.cra_list), 497 .cra_u = { 498 .blkcipher = { 499 .min_keysize = DES3_192_KEY_SIZE, 500 .max_keysize = DES3_192_KEY_SIZE, 501 .setkey = des3_192_setkey, 502 .encrypt = ecb_des3_192_encrypt, 503 .decrypt = ecb_des3_192_decrypt, 504 } 505 } 506 }; 507 508 static int cbc_des3_192_encrypt(struct blkcipher_desc *desc, 509 struct scatterlist *dst, 510 struct scatterlist *src, unsigned int nbytes) 511 { 512 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 513 struct blkcipher_walk walk; 514 515 blkcipher_walk_init(&walk, dst, src, nbytes); 516 return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, sctx->iv, &walk); 517 } 518 519 static int cbc_des3_192_decrypt(struct blkcipher_desc *desc, 520 struct scatterlist *dst, 521 struct scatterlist *src, unsigned int nbytes) 522 { 523 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 524 struct blkcipher_walk walk; 525 526 blkcipher_walk_init(&walk, dst, src, nbytes); 527 return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, sctx->iv, &walk); 528 } 529 530 static struct crypto_alg cbc_des3_192_alg = { 531 .cra_name = "cbc(des3_ede)", 532 .cra_driver_name = "cbc-des3_ede-s390", 533 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 534 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 535 .cra_blocksize = DES3_192_BLOCK_SIZE, 536 .cra_ctxsize = sizeof(struct crypt_s390_des3_192_ctx), 537 .cra_type = &crypto_blkcipher_type, 538 .cra_module = THIS_MODULE, 539 .cra_list = LIST_HEAD_INIT( 540 cbc_des3_192_alg.cra_list), 541 .cra_u = { 542 .blkcipher = { 543 .min_keysize = DES3_192_KEY_SIZE, 544 .max_keysize = DES3_192_KEY_SIZE, 545 .ivsize = DES3_192_BLOCK_SIZE, 546 .setkey = des3_192_setkey, 547 .encrypt = cbc_des3_192_encrypt, 548 .decrypt = cbc_des3_192_decrypt, 549 } 550 } 551 }; 552 553 static int des_s390_init(void) 554 { 555 int ret = 0; 556 557 if (!crypt_s390_func_available(KM_DEA_ENCRYPT) || 558 !crypt_s390_func_available(KM_TDEA_128_ENCRYPT) || 559 !crypt_s390_func_available(KM_TDEA_192_ENCRYPT)) 560 return -EOPNOTSUPP; 561 562 ret = crypto_register_alg(&des_alg); 563 if (ret) 564 goto des_err; 565 ret = crypto_register_alg(&ecb_des_alg); 566 if (ret) 567 goto ecb_des_err; 568 ret = crypto_register_alg(&cbc_des_alg); 569 if (ret) 570 goto cbc_des_err; 571 572 ret = crypto_register_alg(&des3_128_alg); 573 if (ret) 574 goto des3_128_err; 575 ret = crypto_register_alg(&ecb_des3_128_alg); 576 if (ret) 577 goto ecb_des3_128_err; 578 ret = crypto_register_alg(&cbc_des3_128_alg); 579 if (ret) 580 goto cbc_des3_128_err; 581 582 ret = crypto_register_alg(&des3_192_alg); 583 if (ret) 584 goto des3_192_err; 585 ret = crypto_register_alg(&ecb_des3_192_alg); 586 if (ret) 587 goto ecb_des3_192_err; 588 ret = crypto_register_alg(&cbc_des3_192_alg); 589 if (ret) 590 goto cbc_des3_192_err; 591 592 out: 593 return ret; 594 595 cbc_des3_192_err: 596 crypto_unregister_alg(&ecb_des3_192_alg); 597 ecb_des3_192_err: 598 crypto_unregister_alg(&des3_192_alg); 599 des3_192_err: 600 crypto_unregister_alg(&cbc_des3_128_alg); 601 cbc_des3_128_err: 602 crypto_unregister_alg(&ecb_des3_128_alg); 603 ecb_des3_128_err: 604 crypto_unregister_alg(&des3_128_alg); 605 des3_128_err: 606 crypto_unregister_alg(&cbc_des_alg); 607 cbc_des_err: 608 crypto_unregister_alg(&ecb_des_alg); 609 ecb_des_err: 610 crypto_unregister_alg(&des_alg); 611 des_err: 612 goto out; 613 } 614 615 static void __exit des_s390_fini(void) 616 { 617 crypto_unregister_alg(&cbc_des3_192_alg); 618 crypto_unregister_alg(&ecb_des3_192_alg); 619 crypto_unregister_alg(&des3_192_alg); 620 crypto_unregister_alg(&cbc_des3_128_alg); 621 crypto_unregister_alg(&ecb_des3_128_alg); 622 crypto_unregister_alg(&des3_128_alg); 623 crypto_unregister_alg(&cbc_des_alg); 624 crypto_unregister_alg(&ecb_des_alg); 625 crypto_unregister_alg(&des_alg); 626 } 627 628 module_init(des_s390_init); 629 module_exit(des_s390_fini); 630 631 MODULE_ALIAS("des"); 632 MODULE_ALIAS("des3_ede"); 633 634 MODULE_LICENSE("GPL"); 635 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms"); 636