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 <linux/fips.h> 22 #include <crypto/algapi.h> 23 #include <crypto/des.h> 24 #include <asm/cpacf.h> 25 26 #define DES3_KEY_SIZE (3 * DES_KEY_SIZE) 27 28 static u8 *ctrblk; 29 static DEFINE_SPINLOCK(ctrblk_lock); 30 31 static cpacf_mask_t km_functions, kmc_functions, kmctr_functions; 32 33 struct s390_des_ctx { 34 u8 iv[DES_BLOCK_SIZE]; 35 u8 key[DES3_KEY_SIZE]; 36 }; 37 38 static int des_setkey(struct crypto_tfm *tfm, const u8 *key, 39 unsigned int key_len) 40 { 41 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 42 u32 tmp[DES_EXPKEY_WORDS]; 43 44 /* check for weak keys */ 45 if (!des_ekey(tmp, key) && 46 (tfm->crt_flags & CRYPTO_TFM_REQ_WEAK_KEY)) { 47 tfm->crt_flags |= CRYPTO_TFM_RES_WEAK_KEY; 48 return -EINVAL; 49 } 50 51 memcpy(ctx->key, key, key_len); 52 return 0; 53 } 54 55 static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) 56 { 57 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 58 59 cpacf_km(CPACF_KM_DEA, ctx->key, out, in, DES_BLOCK_SIZE); 60 } 61 62 static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) 63 { 64 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 65 66 cpacf_km(CPACF_KM_DEA | CPACF_DECRYPT, 67 ctx->key, out, in, DES_BLOCK_SIZE); 68 } 69 70 static struct crypto_alg des_alg = { 71 .cra_name = "des", 72 .cra_driver_name = "des-s390", 73 .cra_priority = 300, 74 .cra_flags = CRYPTO_ALG_TYPE_CIPHER, 75 .cra_blocksize = DES_BLOCK_SIZE, 76 .cra_ctxsize = sizeof(struct s390_des_ctx), 77 .cra_module = THIS_MODULE, 78 .cra_u = { 79 .cipher = { 80 .cia_min_keysize = DES_KEY_SIZE, 81 .cia_max_keysize = DES_KEY_SIZE, 82 .cia_setkey = des_setkey, 83 .cia_encrypt = des_encrypt, 84 .cia_decrypt = des_decrypt, 85 } 86 } 87 }; 88 89 static int ecb_desall_crypt(struct blkcipher_desc *desc, unsigned long fc, 90 struct blkcipher_walk *walk) 91 { 92 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 93 unsigned int nbytes, n; 94 int ret; 95 96 ret = blkcipher_walk_virt(desc, walk); 97 while ((nbytes = walk->nbytes) >= DES_BLOCK_SIZE) { 98 /* only use complete blocks */ 99 n = nbytes & ~(DES_BLOCK_SIZE - 1); 100 cpacf_km(fc, ctx->key, walk->dst.virt.addr, 101 walk->src.virt.addr, n); 102 ret = blkcipher_walk_done(desc, walk, nbytes - n); 103 } 104 return ret; 105 } 106 107 static int cbc_desall_crypt(struct blkcipher_desc *desc, unsigned long fc, 108 struct blkcipher_walk *walk) 109 { 110 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 111 unsigned int nbytes, n; 112 int ret; 113 struct { 114 u8 iv[DES_BLOCK_SIZE]; 115 u8 key[DES3_KEY_SIZE]; 116 } param; 117 118 ret = blkcipher_walk_virt(desc, walk); 119 memcpy(param.iv, walk->iv, DES_BLOCK_SIZE); 120 memcpy(param.key, ctx->key, DES3_KEY_SIZE); 121 while ((nbytes = walk->nbytes) >= DES_BLOCK_SIZE) { 122 /* only use complete blocks */ 123 n = nbytes & ~(DES_BLOCK_SIZE - 1); 124 cpacf_kmc(fc, ¶m, walk->dst.virt.addr, 125 walk->src.virt.addr, n); 126 ret = blkcipher_walk_done(desc, walk, nbytes - n); 127 } 128 memcpy(walk->iv, param.iv, DES_BLOCK_SIZE); 129 return ret; 130 } 131 132 static int ecb_des_encrypt(struct blkcipher_desc *desc, 133 struct scatterlist *dst, struct scatterlist *src, 134 unsigned int nbytes) 135 { 136 struct blkcipher_walk walk; 137 138 blkcipher_walk_init(&walk, dst, src, nbytes); 139 return ecb_desall_crypt(desc, CPACF_KM_DEA, &walk); 140 } 141 142 static int ecb_des_decrypt(struct blkcipher_desc *desc, 143 struct scatterlist *dst, struct scatterlist *src, 144 unsigned int nbytes) 145 { 146 struct blkcipher_walk walk; 147 148 blkcipher_walk_init(&walk, dst, src, nbytes); 149 return ecb_desall_crypt(desc, CPACF_KM_DEA | CPACF_DECRYPT, &walk); 150 } 151 152 static struct crypto_alg ecb_des_alg = { 153 .cra_name = "ecb(des)", 154 .cra_driver_name = "ecb-des-s390", 155 .cra_priority = 400, /* combo: des + ecb */ 156 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 157 .cra_blocksize = DES_BLOCK_SIZE, 158 .cra_ctxsize = sizeof(struct s390_des_ctx), 159 .cra_type = &crypto_blkcipher_type, 160 .cra_module = THIS_MODULE, 161 .cra_u = { 162 .blkcipher = { 163 .min_keysize = DES_KEY_SIZE, 164 .max_keysize = DES_KEY_SIZE, 165 .setkey = des_setkey, 166 .encrypt = ecb_des_encrypt, 167 .decrypt = ecb_des_decrypt, 168 } 169 } 170 }; 171 172 static int cbc_des_encrypt(struct blkcipher_desc *desc, 173 struct scatterlist *dst, struct scatterlist *src, 174 unsigned int nbytes) 175 { 176 struct blkcipher_walk walk; 177 178 blkcipher_walk_init(&walk, dst, src, nbytes); 179 return cbc_desall_crypt(desc, CPACF_KMC_DEA, &walk); 180 } 181 182 static int cbc_des_decrypt(struct blkcipher_desc *desc, 183 struct scatterlist *dst, struct scatterlist *src, 184 unsigned int nbytes) 185 { 186 struct blkcipher_walk walk; 187 188 blkcipher_walk_init(&walk, dst, src, nbytes); 189 return cbc_desall_crypt(desc, CPACF_KMC_DEA | CPACF_DECRYPT, &walk); 190 } 191 192 static struct crypto_alg cbc_des_alg = { 193 .cra_name = "cbc(des)", 194 .cra_driver_name = "cbc-des-s390", 195 .cra_priority = 400, /* combo: des + cbc */ 196 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 197 .cra_blocksize = DES_BLOCK_SIZE, 198 .cra_ctxsize = sizeof(struct s390_des_ctx), 199 .cra_type = &crypto_blkcipher_type, 200 .cra_module = THIS_MODULE, 201 .cra_u = { 202 .blkcipher = { 203 .min_keysize = DES_KEY_SIZE, 204 .max_keysize = DES_KEY_SIZE, 205 .ivsize = DES_BLOCK_SIZE, 206 .setkey = des_setkey, 207 .encrypt = cbc_des_encrypt, 208 .decrypt = cbc_des_decrypt, 209 } 210 } 211 }; 212 213 /* 214 * RFC2451: 215 * 216 * For DES-EDE3, there is no known need to reject weak or 217 * complementation keys. Any weakness is obviated by the use of 218 * multiple keys. 219 * 220 * However, if the first two or last two independent 64-bit keys are 221 * equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the 222 * same as DES. Implementers MUST reject keys that exhibit this 223 * property. 224 * 225 * In fips mode additinally check for all 3 keys are unique. 226 * 227 */ 228 static int des3_setkey(struct crypto_tfm *tfm, const u8 *key, 229 unsigned int key_len) 230 { 231 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 232 233 if (!(crypto_memneq(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) && 234 crypto_memneq(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2], 235 DES_KEY_SIZE)) && 236 (tfm->crt_flags & CRYPTO_TFM_REQ_WEAK_KEY)) { 237 tfm->crt_flags |= CRYPTO_TFM_RES_WEAK_KEY; 238 return -EINVAL; 239 } 240 241 /* in fips mode, ensure k1 != k2 and k2 != k3 and k1 != k3 */ 242 if (fips_enabled && 243 !(crypto_memneq(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) && 244 crypto_memneq(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2], 245 DES_KEY_SIZE) && 246 crypto_memneq(key, &key[DES_KEY_SIZE * 2], DES_KEY_SIZE))) { 247 tfm->crt_flags |= CRYPTO_TFM_RES_WEAK_KEY; 248 return -EINVAL; 249 } 250 251 memcpy(ctx->key, key, key_len); 252 return 0; 253 } 254 255 static void des3_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 256 { 257 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 258 259 cpacf_km(CPACF_KM_TDEA_192, ctx->key, dst, src, DES_BLOCK_SIZE); 260 } 261 262 static void des3_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 263 { 264 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm); 265 266 cpacf_km(CPACF_KM_TDEA_192 | CPACF_DECRYPT, 267 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 blkcipher_walk walk; 294 295 blkcipher_walk_init(&walk, dst, src, nbytes); 296 return ecb_desall_crypt(desc, CPACF_KM_TDEA_192, &walk); 297 } 298 299 static int ecb_des3_decrypt(struct blkcipher_desc *desc, 300 struct scatterlist *dst, struct scatterlist *src, 301 unsigned int nbytes) 302 { 303 struct blkcipher_walk walk; 304 305 blkcipher_walk_init(&walk, dst, src, nbytes); 306 return ecb_desall_crypt(desc, CPACF_KM_TDEA_192 | CPACF_DECRYPT, 307 &walk); 308 } 309 310 static struct crypto_alg ecb_des3_alg = { 311 .cra_name = "ecb(des3_ede)", 312 .cra_driver_name = "ecb-des3_ede-s390", 313 .cra_priority = 400, /* combo: des3 + ecb */ 314 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 315 .cra_blocksize = DES_BLOCK_SIZE, 316 .cra_ctxsize = sizeof(struct s390_des_ctx), 317 .cra_type = &crypto_blkcipher_type, 318 .cra_module = THIS_MODULE, 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 blkcipher_walk walk; 335 336 blkcipher_walk_init(&walk, dst, src, nbytes); 337 return cbc_desall_crypt(desc, CPACF_KMC_TDEA_192, &walk); 338 } 339 340 static int cbc_des3_decrypt(struct blkcipher_desc *desc, 341 struct scatterlist *dst, struct scatterlist *src, 342 unsigned int nbytes) 343 { 344 struct blkcipher_walk walk; 345 346 blkcipher_walk_init(&walk, dst, src, nbytes); 347 return cbc_desall_crypt(desc, CPACF_KMC_TDEA_192 | CPACF_DECRYPT, 348 &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, u8 *iv, 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 memcpy(ctrptr, iv, DES_BLOCK_SIZE); 379 for (i = (n / DES_BLOCK_SIZE) - 1; i > 0; i--) { 380 memcpy(ctrptr + DES_BLOCK_SIZE, ctrptr, DES_BLOCK_SIZE); 381 crypto_inc(ctrptr + DES_BLOCK_SIZE, DES_BLOCK_SIZE); 382 ctrptr += DES_BLOCK_SIZE; 383 } 384 return n; 385 } 386 387 static int ctr_desall_crypt(struct blkcipher_desc *desc, unsigned long fc, 388 struct blkcipher_walk *walk) 389 { 390 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm); 391 u8 buf[DES_BLOCK_SIZE], *ctrptr; 392 unsigned int n, nbytes; 393 int ret, locked; 394 395 locked = spin_trylock(&ctrblk_lock); 396 397 ret = blkcipher_walk_virt_block(desc, walk, DES_BLOCK_SIZE); 398 while ((nbytes = walk->nbytes) >= DES_BLOCK_SIZE) { 399 n = DES_BLOCK_SIZE; 400 if (nbytes >= 2*DES_BLOCK_SIZE && locked) 401 n = __ctrblk_init(ctrblk, walk->iv, nbytes); 402 ctrptr = (n > DES_BLOCK_SIZE) ? ctrblk : walk->iv; 403 cpacf_kmctr(fc, ctx->key, walk->dst.virt.addr, 404 walk->src.virt.addr, n, ctrptr); 405 if (ctrptr == ctrblk) 406 memcpy(walk->iv, ctrptr + n - DES_BLOCK_SIZE, 407 DES_BLOCK_SIZE); 408 crypto_inc(walk->iv, DES_BLOCK_SIZE); 409 ret = blkcipher_walk_done(desc, walk, nbytes - n); 410 } 411 if (locked) 412 spin_unlock(&ctrblk_lock); 413 /* final block may be < DES_BLOCK_SIZE, copy only nbytes */ 414 if (nbytes) { 415 cpacf_kmctr(fc, ctx->key, buf, walk->src.virt.addr, 416 DES_BLOCK_SIZE, walk->iv); 417 memcpy(walk->dst.virt.addr, buf, nbytes); 418 crypto_inc(walk->iv, DES_BLOCK_SIZE); 419 ret = blkcipher_walk_done(desc, walk, 0); 420 } 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 blkcipher_walk walk; 429 430 blkcipher_walk_init(&walk, dst, src, nbytes); 431 return ctr_desall_crypt(desc, CPACF_KMCTR_DEA, &walk); 432 } 433 434 static int ctr_des_decrypt(struct blkcipher_desc *desc, 435 struct scatterlist *dst, struct scatterlist *src, 436 unsigned int nbytes) 437 { 438 struct blkcipher_walk walk; 439 440 blkcipher_walk_init(&walk, dst, src, nbytes); 441 return ctr_desall_crypt(desc, CPACF_KMCTR_DEA | CPACF_DECRYPT, &walk); 442 } 443 444 static struct crypto_alg ctr_des_alg = { 445 .cra_name = "ctr(des)", 446 .cra_driver_name = "ctr-des-s390", 447 .cra_priority = 400, /* combo: des + ctr */ 448 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 449 .cra_blocksize = 1, 450 .cra_ctxsize = sizeof(struct s390_des_ctx), 451 .cra_type = &crypto_blkcipher_type, 452 .cra_module = THIS_MODULE, 453 .cra_u = { 454 .blkcipher = { 455 .min_keysize = DES_KEY_SIZE, 456 .max_keysize = DES_KEY_SIZE, 457 .ivsize = DES_BLOCK_SIZE, 458 .setkey = des_setkey, 459 .encrypt = ctr_des_encrypt, 460 .decrypt = ctr_des_decrypt, 461 } 462 } 463 }; 464 465 static int ctr_des3_encrypt(struct blkcipher_desc *desc, 466 struct scatterlist *dst, struct scatterlist *src, 467 unsigned int nbytes) 468 { 469 struct blkcipher_walk walk; 470 471 blkcipher_walk_init(&walk, dst, src, nbytes); 472 return ctr_desall_crypt(desc, CPACF_KMCTR_TDEA_192, &walk); 473 } 474 475 static int ctr_des3_decrypt(struct blkcipher_desc *desc, 476 struct scatterlist *dst, struct scatterlist *src, 477 unsigned int nbytes) 478 { 479 struct blkcipher_walk walk; 480 481 blkcipher_walk_init(&walk, dst, src, nbytes); 482 return ctr_desall_crypt(desc, CPACF_KMCTR_TDEA_192 | CPACF_DECRYPT, 483 &walk); 484 } 485 486 static struct crypto_alg ctr_des3_alg = { 487 .cra_name = "ctr(des3_ede)", 488 .cra_driver_name = "ctr-des3_ede-s390", 489 .cra_priority = 400, /* combo: des3 + ede */ 490 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, 491 .cra_blocksize = 1, 492 .cra_ctxsize = sizeof(struct s390_des_ctx), 493 .cra_type = &crypto_blkcipher_type, 494 .cra_module = THIS_MODULE, 495 .cra_u = { 496 .blkcipher = { 497 .min_keysize = DES3_KEY_SIZE, 498 .max_keysize = DES3_KEY_SIZE, 499 .ivsize = DES_BLOCK_SIZE, 500 .setkey = des3_setkey, 501 .encrypt = ctr_des3_encrypt, 502 .decrypt = ctr_des3_decrypt, 503 } 504 } 505 }; 506 507 static struct crypto_alg *des_s390_algs_ptr[8]; 508 static int des_s390_algs_num; 509 510 static int des_s390_register_alg(struct crypto_alg *alg) 511 { 512 int ret; 513 514 ret = crypto_register_alg(alg); 515 if (!ret) 516 des_s390_algs_ptr[des_s390_algs_num++] = alg; 517 return ret; 518 } 519 520 static void des_s390_exit(void) 521 { 522 while (des_s390_algs_num--) 523 crypto_unregister_alg(des_s390_algs_ptr[des_s390_algs_num]); 524 if (ctrblk) 525 free_page((unsigned long) ctrblk); 526 } 527 528 static int __init des_s390_init(void) 529 { 530 int ret; 531 532 /* Query available functions for KM, KMC and KMCTR */ 533 cpacf_query(CPACF_KM, &km_functions); 534 cpacf_query(CPACF_KMC, &kmc_functions); 535 cpacf_query(CPACF_KMCTR, &kmctr_functions); 536 537 if (cpacf_test_func(&km_functions, CPACF_KM_DEA)) { 538 ret = des_s390_register_alg(&des_alg); 539 if (ret) 540 goto out_err; 541 ret = des_s390_register_alg(&ecb_des_alg); 542 if (ret) 543 goto out_err; 544 } 545 if (cpacf_test_func(&kmc_functions, CPACF_KMC_DEA)) { 546 ret = des_s390_register_alg(&cbc_des_alg); 547 if (ret) 548 goto out_err; 549 } 550 if (cpacf_test_func(&km_functions, CPACF_KM_TDEA_192)) { 551 ret = des_s390_register_alg(&des3_alg); 552 if (ret) 553 goto out_err; 554 ret = des_s390_register_alg(&ecb_des3_alg); 555 if (ret) 556 goto out_err; 557 } 558 if (cpacf_test_func(&kmc_functions, CPACF_KMC_TDEA_192)) { 559 ret = des_s390_register_alg(&cbc_des3_alg); 560 if (ret) 561 goto out_err; 562 } 563 564 if (cpacf_test_func(&kmctr_functions, CPACF_KMCTR_DEA) || 565 cpacf_test_func(&kmctr_functions, CPACF_KMCTR_TDEA_192)) { 566 ctrblk = (u8 *) __get_free_page(GFP_KERNEL); 567 if (!ctrblk) { 568 ret = -ENOMEM; 569 goto out_err; 570 } 571 } 572 573 if (cpacf_test_func(&kmctr_functions, CPACF_KMCTR_DEA)) { 574 ret = des_s390_register_alg(&ctr_des_alg); 575 if (ret) 576 goto out_err; 577 } 578 if (cpacf_test_func(&kmctr_functions, CPACF_KMCTR_TDEA_192)) { 579 ret = des_s390_register_alg(&ctr_des3_alg); 580 if (ret) 581 goto out_err; 582 } 583 584 return 0; 585 out_err: 586 des_s390_exit(); 587 return ret; 588 } 589 590 module_cpu_feature_match(MSA, des_s390_init); 591 module_exit(des_s390_exit); 592 593 MODULE_ALIAS_CRYPTO("des"); 594 MODULE_ALIAS_CRYPTO("des3_ede"); 595 596 MODULE_LICENSE("GPL"); 597 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms"); 598