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_REQ_WEAK_KEY)) { 255 *flags |= CRYPTO_TFM_RES_WEAK_KEY; 256 return -EINVAL; 257 } 258 for (i = 0; i < 2; i++, temp_key += DES_KEY_SIZE) { 259 ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags); 260 if (ret < 0) 261 return ret; 262 } 263 memcpy(dctx->key, key, keylen); 264 return 0; 265 } 266 267 static void des3_128_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 268 { 269 struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm); 270 271 crypt_s390_km(KM_TDEA_128_ENCRYPT, dctx->key, dst, (void*)src, 272 DES3_128_BLOCK_SIZE); 273 } 274 275 static void des3_128_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 276 { 277 struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm); 278 279 crypt_s390_km(KM_TDEA_128_DECRYPT, dctx->key, dst, (void*)src, 280 DES3_128_BLOCK_SIZE); 281 } 282 283 static struct crypto_alg des3_128_alg = { 284 .cra_name = "des3_ede128", 285 .cra_driver_name = "des3_ede128-s390", 286 .cra_priority = CRYPT_S390_PRIORITY, 287 .cra_flags = CRYPTO_ALG_TYPE_CIPHER, 288 .cra_blocksize = DES3_128_BLOCK_SIZE, 289 .cra_ctxsize = sizeof(struct crypt_s390_des3_128_ctx), 290 .cra_module = THIS_MODULE, 291 .cra_list = LIST_HEAD_INIT(des3_128_alg.cra_list), 292 .cra_u = { 293 .cipher = { 294 .cia_min_keysize = DES3_128_KEY_SIZE, 295 .cia_max_keysize = DES3_128_KEY_SIZE, 296 .cia_setkey = des3_128_setkey, 297 .cia_encrypt = des3_128_encrypt, 298 .cia_decrypt = des3_128_decrypt, 299 } 300 } 301 }; 302 303 static int ecb_des3_128_encrypt(struct blkcipher_desc *desc, 304 struct scatterlist *dst, 305 struct scatterlist *src, unsigned int nbytes) 306 { 307 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 308 struct blkcipher_walk walk; 309 310 blkcipher_walk_init(&walk, dst, src, nbytes); 311 return ecb_desall_crypt(desc, KM_TDEA_128_ENCRYPT, sctx->key, &walk); 312 } 313 314 static int ecb_des3_128_decrypt(struct blkcipher_desc *desc, 315 struct scatterlist *dst, 316 struct scatterlist *src, unsigned int nbytes) 317 { 318 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 319 struct blkcipher_walk walk; 320 321 blkcipher_walk_init(&walk, dst, src, nbytes); 322 return ecb_desall_crypt(desc, KM_TDEA_128_DECRYPT, sctx->key, &walk); 323 } 324 325 static struct crypto_alg ecb_des3_128_alg = { 326 .cra_name = "ecb(des3_ede128)", 327 .cra_driver_name = "ecb-des3_ede128-s390", 328 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 329 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 330 .cra_blocksize = DES3_128_BLOCK_SIZE, 331 .cra_ctxsize = sizeof(struct crypt_s390_des3_128_ctx), 332 .cra_type = &crypto_blkcipher_type, 333 .cra_module = THIS_MODULE, 334 .cra_list = LIST_HEAD_INIT( 335 ecb_des3_128_alg.cra_list), 336 .cra_u = { 337 .blkcipher = { 338 .min_keysize = DES3_128_KEY_SIZE, 339 .max_keysize = DES3_128_KEY_SIZE, 340 .setkey = des3_128_setkey, 341 .encrypt = ecb_des3_128_encrypt, 342 .decrypt = ecb_des3_128_decrypt, 343 } 344 } 345 }; 346 347 static int cbc_des3_128_encrypt(struct blkcipher_desc *desc, 348 struct scatterlist *dst, 349 struct scatterlist *src, unsigned int nbytes) 350 { 351 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 352 struct blkcipher_walk walk; 353 354 blkcipher_walk_init(&walk, dst, src, nbytes); 355 return cbc_desall_crypt(desc, KMC_TDEA_128_ENCRYPT, sctx->iv, &walk); 356 } 357 358 static int cbc_des3_128_decrypt(struct blkcipher_desc *desc, 359 struct scatterlist *dst, 360 struct scatterlist *src, unsigned int nbytes) 361 { 362 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 363 struct blkcipher_walk walk; 364 365 blkcipher_walk_init(&walk, dst, src, nbytes); 366 return cbc_desall_crypt(desc, KMC_TDEA_128_DECRYPT, sctx->iv, &walk); 367 } 368 369 static struct crypto_alg cbc_des3_128_alg = { 370 .cra_name = "cbc(des3_ede128)", 371 .cra_driver_name = "cbc-des3_ede128-s390", 372 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 373 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 374 .cra_blocksize = DES3_128_BLOCK_SIZE, 375 .cra_ctxsize = sizeof(struct crypt_s390_des3_128_ctx), 376 .cra_type = &crypto_blkcipher_type, 377 .cra_module = THIS_MODULE, 378 .cra_list = LIST_HEAD_INIT( 379 cbc_des3_128_alg.cra_list), 380 .cra_u = { 381 .blkcipher = { 382 .min_keysize = DES3_128_KEY_SIZE, 383 .max_keysize = DES3_128_KEY_SIZE, 384 .ivsize = DES3_128_BLOCK_SIZE, 385 .setkey = des3_128_setkey, 386 .encrypt = cbc_des3_128_encrypt, 387 .decrypt = cbc_des3_128_decrypt, 388 } 389 } 390 }; 391 392 /* 393 * RFC2451: 394 * 395 * For DES-EDE3, there is no known need to reject weak or 396 * complementation keys. Any weakness is obviated by the use of 397 * multiple keys. 398 * 399 * However, if the first two or last two independent 64-bit keys are 400 * equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the 401 * same as DES. Implementers MUST reject keys that exhibit this 402 * property. 403 * 404 */ 405 static int des3_192_setkey(struct crypto_tfm *tfm, const u8 *key, 406 unsigned int keylen) 407 { 408 int i, ret; 409 struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm); 410 const u8 *temp_key = key; 411 u32 *flags = &tfm->crt_flags; 412 413 if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) && 414 memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2], 415 DES_KEY_SIZE)) && 416 (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) { 417 *flags |= CRYPTO_TFM_RES_WEAK_KEY; 418 return -EINVAL; 419 } 420 for (i = 0; i < 3; i++, temp_key += DES_KEY_SIZE) { 421 ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags); 422 if (ret < 0) 423 return ret; 424 } 425 memcpy(dctx->key, key, keylen); 426 return 0; 427 } 428 429 static void des3_192_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 430 { 431 struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm); 432 433 crypt_s390_km(KM_TDEA_192_ENCRYPT, dctx->key, dst, (void*)src, 434 DES3_192_BLOCK_SIZE); 435 } 436 437 static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 438 { 439 struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm); 440 441 crypt_s390_km(KM_TDEA_192_DECRYPT, dctx->key, dst, (void*)src, 442 DES3_192_BLOCK_SIZE); 443 } 444 445 static struct crypto_alg des3_192_alg = { 446 .cra_name = "des3_ede", 447 .cra_driver_name = "des3_ede-s390", 448 .cra_priority = CRYPT_S390_PRIORITY, 449 .cra_flags = CRYPTO_ALG_TYPE_CIPHER, 450 .cra_blocksize = DES3_192_BLOCK_SIZE, 451 .cra_ctxsize = sizeof(struct crypt_s390_des3_192_ctx), 452 .cra_module = THIS_MODULE, 453 .cra_list = LIST_HEAD_INIT(des3_192_alg.cra_list), 454 .cra_u = { 455 .cipher = { 456 .cia_min_keysize = DES3_192_KEY_SIZE, 457 .cia_max_keysize = DES3_192_KEY_SIZE, 458 .cia_setkey = des3_192_setkey, 459 .cia_encrypt = des3_192_encrypt, 460 .cia_decrypt = des3_192_decrypt, 461 } 462 } 463 }; 464 465 static int ecb_des3_192_encrypt(struct blkcipher_desc *desc, 466 struct scatterlist *dst, 467 struct scatterlist *src, unsigned int nbytes) 468 { 469 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 470 struct blkcipher_walk walk; 471 472 blkcipher_walk_init(&walk, dst, src, nbytes); 473 return ecb_desall_crypt(desc, KM_TDEA_192_ENCRYPT, sctx->key, &walk); 474 } 475 476 static int ecb_des3_192_decrypt(struct blkcipher_desc *desc, 477 struct scatterlist *dst, 478 struct scatterlist *src, unsigned int nbytes) 479 { 480 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 481 struct blkcipher_walk walk; 482 483 blkcipher_walk_init(&walk, dst, src, nbytes); 484 return ecb_desall_crypt(desc, KM_TDEA_192_DECRYPT, sctx->key, &walk); 485 } 486 487 static struct crypto_alg ecb_des3_192_alg = { 488 .cra_name = "ecb(des3_ede)", 489 .cra_driver_name = "ecb-des3_ede-s390", 490 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 491 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 492 .cra_blocksize = DES3_192_BLOCK_SIZE, 493 .cra_ctxsize = sizeof(struct crypt_s390_des3_192_ctx), 494 .cra_type = &crypto_blkcipher_type, 495 .cra_module = THIS_MODULE, 496 .cra_list = LIST_HEAD_INIT( 497 ecb_des3_192_alg.cra_list), 498 .cra_u = { 499 .blkcipher = { 500 .min_keysize = DES3_192_KEY_SIZE, 501 .max_keysize = DES3_192_KEY_SIZE, 502 .setkey = des3_192_setkey, 503 .encrypt = ecb_des3_192_encrypt, 504 .decrypt = ecb_des3_192_decrypt, 505 } 506 } 507 }; 508 509 static int cbc_des3_192_encrypt(struct blkcipher_desc *desc, 510 struct scatterlist *dst, 511 struct scatterlist *src, unsigned int nbytes) 512 { 513 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 514 struct blkcipher_walk walk; 515 516 blkcipher_walk_init(&walk, dst, src, nbytes); 517 return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, sctx->iv, &walk); 518 } 519 520 static int cbc_des3_192_decrypt(struct blkcipher_desc *desc, 521 struct scatterlist *dst, 522 struct scatterlist *src, unsigned int nbytes) 523 { 524 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); 525 struct blkcipher_walk walk; 526 527 blkcipher_walk_init(&walk, dst, src, nbytes); 528 return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, sctx->iv, &walk); 529 } 530 531 static struct crypto_alg cbc_des3_192_alg = { 532 .cra_name = "cbc(des3_ede)", 533 .cra_driver_name = "cbc-des3_ede-s390", 534 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY, 535 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 536 .cra_blocksize = DES3_192_BLOCK_SIZE, 537 .cra_ctxsize = sizeof(struct crypt_s390_des3_192_ctx), 538 .cra_type = &crypto_blkcipher_type, 539 .cra_module = THIS_MODULE, 540 .cra_list = LIST_HEAD_INIT( 541 cbc_des3_192_alg.cra_list), 542 .cra_u = { 543 .blkcipher = { 544 .min_keysize = DES3_192_KEY_SIZE, 545 .max_keysize = DES3_192_KEY_SIZE, 546 .ivsize = DES3_192_BLOCK_SIZE, 547 .setkey = des3_192_setkey, 548 .encrypt = cbc_des3_192_encrypt, 549 .decrypt = cbc_des3_192_decrypt, 550 } 551 } 552 }; 553 554 static int des_s390_init(void) 555 { 556 int ret = 0; 557 558 if (!crypt_s390_func_available(KM_DEA_ENCRYPT) || 559 !crypt_s390_func_available(KM_TDEA_128_ENCRYPT) || 560 !crypt_s390_func_available(KM_TDEA_192_ENCRYPT)) 561 return -EOPNOTSUPP; 562 563 ret = crypto_register_alg(&des_alg); 564 if (ret) 565 goto des_err; 566 ret = crypto_register_alg(&ecb_des_alg); 567 if (ret) 568 goto ecb_des_err; 569 ret = crypto_register_alg(&cbc_des_alg); 570 if (ret) 571 goto cbc_des_err; 572 573 ret = crypto_register_alg(&des3_128_alg); 574 if (ret) 575 goto des3_128_err; 576 ret = crypto_register_alg(&ecb_des3_128_alg); 577 if (ret) 578 goto ecb_des3_128_err; 579 ret = crypto_register_alg(&cbc_des3_128_alg); 580 if (ret) 581 goto cbc_des3_128_err; 582 583 ret = crypto_register_alg(&des3_192_alg); 584 if (ret) 585 goto des3_192_err; 586 ret = crypto_register_alg(&ecb_des3_192_alg); 587 if (ret) 588 goto ecb_des3_192_err; 589 ret = crypto_register_alg(&cbc_des3_192_alg); 590 if (ret) 591 goto cbc_des3_192_err; 592 593 out: 594 return ret; 595 596 cbc_des3_192_err: 597 crypto_unregister_alg(&ecb_des3_192_alg); 598 ecb_des3_192_err: 599 crypto_unregister_alg(&des3_192_alg); 600 des3_192_err: 601 crypto_unregister_alg(&cbc_des3_128_alg); 602 cbc_des3_128_err: 603 crypto_unregister_alg(&ecb_des3_128_alg); 604 ecb_des3_128_err: 605 crypto_unregister_alg(&des3_128_alg); 606 des3_128_err: 607 crypto_unregister_alg(&cbc_des_alg); 608 cbc_des_err: 609 crypto_unregister_alg(&ecb_des_alg); 610 ecb_des_err: 611 crypto_unregister_alg(&des_alg); 612 des_err: 613 goto out; 614 } 615 616 static void __exit des_s390_fini(void) 617 { 618 crypto_unregister_alg(&cbc_des3_192_alg); 619 crypto_unregister_alg(&ecb_des3_192_alg); 620 crypto_unregister_alg(&des3_192_alg); 621 crypto_unregister_alg(&cbc_des3_128_alg); 622 crypto_unregister_alg(&ecb_des3_128_alg); 623 crypto_unregister_alg(&des3_128_alg); 624 crypto_unregister_alg(&cbc_des_alg); 625 crypto_unregister_alg(&ecb_des_alg); 626 crypto_unregister_alg(&des_alg); 627 } 628 629 module_init(des_s390_init); 630 module_exit(des_s390_fini); 631 632 MODULE_ALIAS("des"); 633 MODULE_ALIAS("des3_ede"); 634 635 MODULE_LICENSE("GPL"); 636 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms"); 637