1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 * 21 */ 22 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 30 /* 31 * Portions of this source code were derived from Berkeley 4.3 BSD 32 * under license from the Regents of the University of California. 33 */ 34 35 /* 36 * des_crypt.c, DES encryption library routines 37 */ 38 39 #include <sys/errno.h> 40 #include <sys/modctl.h> 41 42 #include <sys/systm.h> 43 #include <sys/cmn_err.h> 44 #include <sys/ddi.h> 45 #include <sys/crypto/common.h> 46 #include <sys/crypto/spi.h> 47 #include <sys/sysmacros.h> 48 #include <sys/strsun.h> 49 #include <sys/note.h> 50 #include <modes/modes.h> 51 #define _DES_IMPL 52 #include <des/des_impl.h> 53 54 #include <sys/types.h> 55 #include <rpc/des_crypt.h> 56 #include <des/des.h> 57 58 #ifdef sun_hardware 59 #include <sys/ioctl.h> 60 #ifdef _KERNEL 61 #include <sys/conf.h> 62 static int g_desfd = -1; 63 #define getdesfd() (cdevsw[11].d_open(0, 0) ? -1 : 0) 64 #define ioctl(a, b, c) (cdevsw[11].d_ioctl(0, b, c, 0) ? -1 : 0) 65 #else 66 #define getdesfd() (open("/dev/des", 0, 0)) 67 #endif /* _KERNEL */ 68 #endif /* sun */ 69 70 static int common_crypt(char *key, char *buf, size_t len, 71 unsigned int mode, struct desparams *desp); 72 73 extern int _des_crypt(char *buf, size_t len, struct desparams *desp); 74 75 extern struct mod_ops mod_cryptoops; 76 77 /* 78 * Module linkage information for the kernel. 79 */ 80 static struct modlmisc modlmisc = { 81 &mod_miscops, 82 "des encryption", 83 }; 84 85 static struct modlcrypto modlcrypto = { 86 &mod_cryptoops, 87 "DES Kernel SW Provider" 88 }; 89 90 static struct modlinkage modlinkage = { 91 MODREV_1, 92 &modlmisc, 93 &modlcrypto, 94 NULL 95 }; 96 97 #define DES_MIN_KEY_LEN DES_MINBYTES 98 #define DES_MAX_KEY_LEN DES_MAXBYTES 99 #define DES3_MIN_KEY_LEN DES3_MAXBYTES /* no CKK_DES2 support */ 100 #define DES3_MAX_KEY_LEN DES3_MAXBYTES 101 102 #ifndef DES_MIN_KEY_LEN 103 #define DES_MIN_KEY_LEN 0 104 #endif 105 106 #ifndef DES_MAX_KEY_LEN 107 #define DES_MAX_KEY_LEN 0 108 #endif 109 110 #ifndef DES3_MIN_KEY_LEN 111 #define DES3_MIN_KEY_LEN 0 112 #endif 113 114 #ifndef DES3_MAX_KEY_LEN 115 #define DES3_MAX_KEY_LEN 0 116 #endif 117 118 119 /* 120 * Mechanism info structure passed to KCF during registration. 121 */ 122 static crypto_mech_info_t des_mech_info_tab[] = { 123 /* DES_ECB */ 124 {SUN_CKM_DES_ECB, DES_ECB_MECH_INFO_TYPE, 125 CRYPTO_FG_ENCRYPT | CRYPTO_FG_ENCRYPT_ATOMIC | 126 CRYPTO_FG_DECRYPT | CRYPTO_FG_DECRYPT_ATOMIC, 127 DES_MIN_KEY_LEN, DES_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES}, 128 /* DES_CBC */ 129 {SUN_CKM_DES_CBC, DES_CBC_MECH_INFO_TYPE, 130 CRYPTO_FG_ENCRYPT | CRYPTO_FG_ENCRYPT_ATOMIC | 131 CRYPTO_FG_DECRYPT | CRYPTO_FG_DECRYPT_ATOMIC, 132 DES_MIN_KEY_LEN, DES_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES}, 133 /* DES3_ECB */ 134 {SUN_CKM_DES3_ECB, DES3_ECB_MECH_INFO_TYPE, 135 CRYPTO_FG_ENCRYPT | CRYPTO_FG_ENCRYPT_ATOMIC | 136 CRYPTO_FG_DECRYPT | CRYPTO_FG_DECRYPT_ATOMIC, 137 DES3_MIN_KEY_LEN, DES3_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES}, 138 /* DES3_CBC */ 139 {SUN_CKM_DES3_CBC, DES3_CBC_MECH_INFO_TYPE, 140 CRYPTO_FG_ENCRYPT | CRYPTO_FG_ENCRYPT_ATOMIC | 141 CRYPTO_FG_DECRYPT | CRYPTO_FG_DECRYPT_ATOMIC, 142 DES3_MIN_KEY_LEN, DES3_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES} 143 }; 144 145 /* operations are in-place if the output buffer is NULL */ 146 #define DES_ARG_INPLACE(input, output) \ 147 if ((output) == NULL) \ 148 (output) = (input); 149 150 static void des_provider_status(crypto_provider_handle_t, uint_t *); 151 152 static crypto_control_ops_t des_control_ops = { 153 des_provider_status 154 }; 155 156 static int 157 des_common_init(crypto_ctx_t *, crypto_mechanism_t *, crypto_key_t *, 158 crypto_spi_ctx_template_t, crypto_req_handle_t); 159 static int des_common_init_ctx(des_ctx_t *, crypto_spi_ctx_template_t *, 160 crypto_mechanism_t *, crypto_key_t *, des_strength_t, int); 161 static int des_encrypt_final(crypto_ctx_t *, crypto_data_t *, 162 crypto_req_handle_t); 163 static int des_decrypt_final(crypto_ctx_t *, crypto_data_t *, 164 crypto_req_handle_t); 165 166 static int des_encrypt(crypto_ctx_t *, crypto_data_t *, crypto_data_t *, 167 crypto_req_handle_t); 168 static int des_encrypt_update(crypto_ctx_t *, crypto_data_t *, 169 crypto_data_t *, crypto_req_handle_t); 170 static int des_encrypt_atomic(crypto_provider_handle_t, crypto_session_id_t, 171 crypto_mechanism_t *, crypto_key_t *, crypto_data_t *, 172 crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t); 173 174 static int des_decrypt(crypto_ctx_t *, crypto_data_t *, crypto_data_t *, 175 crypto_req_handle_t); 176 static int des_decrypt_update(crypto_ctx_t *, crypto_data_t *, 177 crypto_data_t *, crypto_req_handle_t); 178 static int des_decrypt_atomic(crypto_provider_handle_t, crypto_session_id_t, 179 crypto_mechanism_t *, crypto_key_t *, crypto_data_t *, 180 crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t); 181 182 static crypto_cipher_ops_t des_cipher_ops = { 183 des_common_init, 184 des_encrypt, 185 des_encrypt_update, 186 des_encrypt_final, 187 des_encrypt_atomic, 188 des_common_init, 189 des_decrypt, 190 des_decrypt_update, 191 des_decrypt_final, 192 des_decrypt_atomic 193 }; 194 195 static int des_create_ctx_template(crypto_provider_handle_t, 196 crypto_mechanism_t *, crypto_key_t *, crypto_spi_ctx_template_t *, 197 size_t *, crypto_req_handle_t); 198 static int des_free_context(crypto_ctx_t *); 199 200 static crypto_ctx_ops_t des_ctx_ops = { 201 des_create_ctx_template, 202 des_free_context 203 }; 204 205 static int des_key_check(crypto_provider_handle_t, crypto_mechanism_t *, 206 crypto_key_t *); 207 208 static crypto_key_ops_t des_key_ops = { 209 NULL, 210 NULL, 211 NULL, 212 NULL, 213 NULL, 214 des_key_check 215 }; 216 217 static crypto_ops_t des_crypto_ops = { 218 &des_control_ops, 219 NULL, 220 &des_cipher_ops, 221 NULL, 222 NULL, 223 NULL, 224 NULL, 225 NULL, 226 NULL, 227 NULL, 228 NULL, 229 &des_key_ops, 230 NULL, 231 &des_ctx_ops, 232 NULL, 233 NULL, 234 NULL 235 }; 236 237 static crypto_provider_info_t des_prov_info = { 238 CRYPTO_SPI_VERSION_4, 239 "DES Software Provider", 240 CRYPTO_SW_PROVIDER, 241 {&modlinkage}, 242 NULL, 243 &des_crypto_ops, 244 sizeof (des_mech_info_tab)/sizeof (crypto_mech_info_t), 245 des_mech_info_tab 246 }; 247 248 static crypto_kcf_provider_handle_t des_prov_handle = 0; 249 250 int 251 _init(void) 252 { 253 int ret; 254 255 if ((ret = mod_install(&modlinkage)) != 0) 256 return (ret); 257 258 /* 259 * Register with KCF. If the registration fails, kcf will log an 260 * error but do not uninstall the module, since the functionality 261 * provided by misc/des should still be available. 262 * 263 */ 264 (void) crypto_register_provider(&des_prov_info, &des_prov_handle); 265 266 return (0); 267 } 268 269 270 int 271 _info(struct modinfo *modinfop) 272 { 273 return (mod_info(&modlinkage, modinfop)); 274 } 275 276 /* 277 * Copy 8 bytes 278 */ 279 #define COPY8(src, dst) { \ 280 char *a = (char *)dst; \ 281 char *b = (char *)src; \ 282 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \ 283 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \ 284 } 285 286 /* 287 * Copy multiple of 8 bytes 288 */ 289 #define DESCOPY(src, dst, len) { \ 290 char *a = (char *)dst; \ 291 char *b = (char *)src; \ 292 int i; \ 293 for (i = (size_t)len; i > 0; i -= 8) { \ 294 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \ 295 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \ 296 } \ 297 } 298 299 /* 300 * CBC mode encryption 301 */ 302 /* ARGSUSED */ 303 int 304 cbc_crypt(char *key, char *buf, size_t len, unsigned int mode, char *ivec) 305 { 306 int err = 0; 307 struct desparams dp; 308 309 dp.des_mode = CBC; 310 COPY8(ivec, dp.des_ivec); 311 err = common_crypt(key, buf, len, mode, &dp); 312 COPY8(dp.des_ivec, ivec); 313 return (err); 314 } 315 316 317 /* 318 * ECB mode encryption 319 */ 320 /* ARGSUSED */ 321 int 322 ecb_crypt(char *key, char *buf, size_t len, unsigned int mode) 323 { 324 int err = 0; 325 struct desparams dp; 326 327 dp.des_mode = ECB; 328 err = common_crypt(key, buf, len, mode, &dp); 329 return (err); 330 } 331 332 333 334 /* 335 * Common code to cbc_crypt() & ecb_crypt() 336 */ 337 static int 338 common_crypt(char *key, char *buf, size_t len, unsigned int mode, 339 struct desparams *desp) 340 { 341 int desdev; 342 343 if ((len % 8) != 0 || len > DES_MAXDATA) 344 return (DESERR_BADPARAM); 345 346 desp->des_dir = 347 ((mode & DES_DIRMASK) == DES_ENCRYPT) ? ENCRYPT : DECRYPT; 348 349 desdev = mode & DES_DEVMASK; 350 COPY8(key, desp->des_key); 351 352 #ifdef sun_hardware 353 if (desdev == DES_HW) { 354 int res; 355 356 if (g_desfd < 0 && 357 (g_desfd == -1 || (g_desfd = getdesfd()) < 0)) 358 goto software; /* no hardware device */ 359 360 /* 361 * hardware 362 */ 363 desp->des_len = len; 364 if (len <= DES_QUICKLEN) { 365 DESCOPY(buf, desp->des_data, len); 366 res = ioctl(g_desfd, DESIOCQUICK, (char *)desp); 367 DESCOPY(desp->des_data, buf, len); 368 } else { 369 desp->des_buf = (uchar_t *)buf; 370 res = ioctl(g_desfd, DESIOCBLOCK, (char *)desp); 371 } 372 return (res == 0 ? DESERR_NONE : DESERR_HWERROR); 373 } 374 software: 375 #endif 376 /* 377 * software 378 */ 379 if (!_des_crypt(buf, len, desp)) 380 return (DESERR_HWERROR); 381 382 return (desdev == DES_SW ? DESERR_NONE : DESERR_NOHWDEVICE); 383 } 384 385 /* 386 * Initialize key schedules for DES and DES3 387 */ 388 static int 389 init_keysched(crypto_key_t *key, void *newbie, des_strength_t strength) 390 { 391 uint8_t corrected_key[DES3_KEYSIZE]; 392 393 /* 394 * Only keys by value are supported by this module. 395 */ 396 switch (key->ck_format) { 397 case CRYPTO_KEY_RAW: 398 if (strength == DES && key->ck_length != DES_MAXBITS) 399 return (CRYPTO_KEY_SIZE_RANGE); 400 if (strength == DES3 && key->ck_length != DES3_MAXBITS) 401 return (CRYPTO_KEY_SIZE_RANGE); 402 break; 403 default: 404 return (CRYPTO_KEY_TYPE_INCONSISTENT); 405 } 406 407 /* 408 * Fix parity bits. 409 * Initialize key schedule even if key is weak. 410 */ 411 if (key->ck_data == NULL) 412 return (CRYPTO_ARGUMENTS_BAD); 413 414 des_parity_fix(key->ck_data, strength, corrected_key); 415 des_init_keysched(corrected_key, strength, newbie); 416 return (CRYPTO_SUCCESS); 417 } 418 419 /* 420 * KCF software provider control entry points. 421 */ 422 /* ARGSUSED */ 423 static void 424 des_provider_status(crypto_provider_handle_t provider, uint_t *status) 425 { 426 *status = CRYPTO_PROVIDER_READY; 427 } 428 429 /* 430 * KCF software provider encrypt entry points. 431 */ 432 static int 433 des_common_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism, 434 crypto_key_t *key, crypto_spi_ctx_template_t template, 435 crypto_req_handle_t req) 436 { 437 438 des_strength_t strength; 439 des_ctx_t *des_ctx = NULL; 440 int rv; 441 int kmflag; 442 443 /* 444 * Only keys by value are supported by this module. 445 */ 446 if (key->ck_format != CRYPTO_KEY_RAW) { 447 return (CRYPTO_KEY_TYPE_INCONSISTENT); 448 } 449 450 kmflag = crypto_kmflag(req); 451 /* Check mechanism type and parameter length */ 452 switch (mechanism->cm_type) { 453 case DES_ECB_MECH_INFO_TYPE: 454 des_ctx = ecb_alloc_ctx(kmflag); 455 /* FALLTHRU */ 456 case DES_CBC_MECH_INFO_TYPE: 457 if (mechanism->cm_param != NULL && 458 mechanism->cm_param_len != DES_BLOCK_LEN) 459 return (CRYPTO_MECHANISM_PARAM_INVALID); 460 if (key->ck_length != DES_MAXBITS) 461 return (CRYPTO_KEY_SIZE_RANGE); 462 strength = DES; 463 if (des_ctx == NULL) 464 des_ctx = cbc_alloc_ctx(kmflag); 465 break; 466 case DES3_ECB_MECH_INFO_TYPE: 467 des_ctx = ecb_alloc_ctx(kmflag); 468 /* FALLTHRU */ 469 case DES3_CBC_MECH_INFO_TYPE: 470 if (mechanism->cm_param != NULL && 471 mechanism->cm_param_len != DES_BLOCK_LEN) 472 return (CRYPTO_MECHANISM_PARAM_INVALID); 473 if (key->ck_length != DES3_MAXBITS) 474 return (CRYPTO_KEY_SIZE_RANGE); 475 strength = DES3; 476 if (des_ctx == NULL) 477 des_ctx = cbc_alloc_ctx(kmflag); 478 break; 479 default: 480 return (CRYPTO_MECHANISM_INVALID); 481 } 482 483 if ((rv = des_common_init_ctx(des_ctx, template, mechanism, key, 484 strength, kmflag)) != CRYPTO_SUCCESS) { 485 crypto_free_mode_ctx(des_ctx); 486 return (rv); 487 } 488 489 ctx->cc_provider_private = des_ctx; 490 491 return (CRYPTO_SUCCESS); 492 } 493 494 static void 495 des_copy_block64(uint8_t *in, uint64_t *out) 496 { 497 if (IS_P2ALIGNED(in, sizeof (uint64_t))) { 498 /* LINTED: pointer alignment */ 499 out[0] = *(uint64_t *)&in[0]; 500 } else { 501 uint64_t tmp64; 502 503 #ifdef _BIG_ENDIAN 504 tmp64 = (((uint64_t)in[0] << 56) | 505 ((uint64_t)in[1] << 48) | 506 ((uint64_t)in[2] << 40) | 507 ((uint64_t)in[3] << 32) | 508 ((uint64_t)in[4] << 24) | 509 ((uint64_t)in[5] << 16) | 510 ((uint64_t)in[6] << 8) | 511 (uint64_t)in[7]); 512 #else 513 tmp64 = (((uint64_t)in[7] << 56) | 514 ((uint64_t)in[6] << 48) | 515 ((uint64_t)in[5] << 40) | 516 ((uint64_t)in[4] << 32) | 517 ((uint64_t)in[3] << 24) | 518 ((uint64_t)in[2] << 16) | 519 ((uint64_t)in[1] << 8) | 520 (uint64_t)in[0]); 521 #endif /* _BIG_ENDIAN */ 522 523 out[0] = tmp64; 524 } 525 } 526 527 /* ARGSUSED */ 528 static int 529 des_encrypt(crypto_ctx_t *ctx, crypto_data_t *plaintext, 530 crypto_data_t *ciphertext, crypto_req_handle_t req) 531 { 532 int ret; 533 534 des_ctx_t *des_ctx; 535 536 /* 537 * Plaintext must be a multiple of the block size. 538 * This test only works for non-padded mechanisms 539 * when blocksize is 2^N. 540 */ 541 if ((plaintext->cd_length & (DES_BLOCK_LEN - 1)) != 0) 542 return (CRYPTO_DATA_LEN_RANGE); 543 544 ASSERT(ctx->cc_provider_private != NULL); 545 des_ctx = ctx->cc_provider_private; 546 547 DES_ARG_INPLACE(plaintext, ciphertext); 548 549 /* 550 * We need to just return the length needed to store the output. 551 * We should not destroy the context for the following case. 552 */ 553 if (ciphertext->cd_length < plaintext->cd_length) { 554 ciphertext->cd_length = plaintext->cd_length; 555 return (CRYPTO_BUFFER_TOO_SMALL); 556 } 557 558 /* 559 * Do an update on the specified input data. 560 */ 561 ret = des_encrypt_update(ctx, plaintext, ciphertext, req); 562 ASSERT(des_ctx->dc_remainder_len == 0); 563 (void) des_free_context(ctx); 564 565 /* LINTED */ 566 return (ret); 567 } 568 569 /* ARGSUSED */ 570 static int 571 des_decrypt(crypto_ctx_t *ctx, crypto_data_t *ciphertext, 572 crypto_data_t *plaintext, crypto_req_handle_t req) 573 { 574 int ret; 575 576 des_ctx_t *des_ctx; 577 578 /* 579 * Ciphertext must be a multiple of the block size. 580 * This test only works for non-padded mechanisms 581 * when blocksize is 2^N. 582 */ 583 if ((ciphertext->cd_length & (DES_BLOCK_LEN - 1)) != 0) 584 return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE); 585 586 ASSERT(ctx->cc_provider_private != NULL); 587 des_ctx = ctx->cc_provider_private; 588 589 DES_ARG_INPLACE(ciphertext, plaintext); 590 591 /* 592 * We need to just return the length needed to store the output. 593 * We should not destroy the context for the following case. 594 */ 595 if (plaintext->cd_length < ciphertext->cd_length) { 596 plaintext->cd_length = ciphertext->cd_length; 597 return (CRYPTO_BUFFER_TOO_SMALL); 598 } 599 600 /* 601 * Do an update on the specified input data. 602 */ 603 ret = des_decrypt_update(ctx, ciphertext, plaintext, req); 604 ASSERT(des_ctx->dc_remainder_len == 0); 605 (void) des_free_context(ctx); 606 607 /* LINTED */ 608 return (ret); 609 } 610 611 /* ARGSUSED */ 612 static int 613 des_encrypt_update(crypto_ctx_t *ctx, crypto_data_t *plaintext, 614 crypto_data_t *ciphertext, crypto_req_handle_t req) 615 { 616 off_t saved_offset; 617 size_t saved_length, out_len; 618 int ret = CRYPTO_SUCCESS; 619 620 ASSERT(ctx->cc_provider_private != NULL); 621 622 DES_ARG_INPLACE(plaintext, ciphertext); 623 624 /* compute number of bytes that will hold the ciphertext */ 625 out_len = ((des_ctx_t *)ctx->cc_provider_private)->dc_remainder_len; 626 out_len += plaintext->cd_length; 627 out_len &= ~(DES_BLOCK_LEN - 1); 628 629 /* return length needed to store the output */ 630 if (ciphertext->cd_length < out_len) { 631 ciphertext->cd_length = out_len; 632 return (CRYPTO_BUFFER_TOO_SMALL); 633 } 634 635 saved_offset = ciphertext->cd_offset; 636 saved_length = ciphertext->cd_length; 637 638 /* 639 * Do the DES update on the specified input data. 640 */ 641 switch (plaintext->cd_format) { 642 case CRYPTO_DATA_RAW: 643 ret = crypto_update_iov(ctx->cc_provider_private, 644 plaintext, ciphertext, des_encrypt_contiguous_blocks, 645 des_copy_block64); 646 break; 647 case CRYPTO_DATA_UIO: 648 ret = crypto_update_uio(ctx->cc_provider_private, 649 plaintext, ciphertext, des_encrypt_contiguous_blocks, 650 des_copy_block64); 651 break; 652 case CRYPTO_DATA_MBLK: 653 ret = crypto_update_mp(ctx->cc_provider_private, 654 plaintext, ciphertext, des_encrypt_contiguous_blocks, 655 des_copy_block64); 656 break; 657 default: 658 ret = CRYPTO_ARGUMENTS_BAD; 659 } 660 661 if (ret == CRYPTO_SUCCESS) { 662 if (plaintext != ciphertext) 663 ciphertext->cd_length = 664 ciphertext->cd_offset - saved_offset; 665 } else { 666 ciphertext->cd_length = saved_length; 667 } 668 ciphertext->cd_offset = saved_offset; 669 670 return (ret); 671 } 672 673 /* ARGSUSED */ 674 static int 675 des_decrypt_update(crypto_ctx_t *ctx, crypto_data_t *ciphertext, 676 crypto_data_t *plaintext, crypto_req_handle_t req) 677 { 678 off_t saved_offset; 679 size_t saved_length, out_len; 680 int ret = CRYPTO_SUCCESS; 681 682 ASSERT(ctx->cc_provider_private != NULL); 683 684 DES_ARG_INPLACE(ciphertext, plaintext); 685 686 /* compute number of bytes that will hold the plaintext */ 687 out_len = ((des_ctx_t *)ctx->cc_provider_private)->dc_remainder_len; 688 out_len += ciphertext->cd_length; 689 out_len &= ~(DES_BLOCK_LEN - 1); 690 691 /* return length needed to store the output */ 692 if (plaintext->cd_length < out_len) { 693 plaintext->cd_length = out_len; 694 return (CRYPTO_BUFFER_TOO_SMALL); 695 } 696 697 saved_offset = plaintext->cd_offset; 698 saved_length = plaintext->cd_length; 699 700 /* 701 * Do the DES update on the specified input data. 702 */ 703 switch (ciphertext->cd_format) { 704 case CRYPTO_DATA_RAW: 705 ret = crypto_update_iov(ctx->cc_provider_private, 706 ciphertext, plaintext, des_decrypt_contiguous_blocks, 707 des_copy_block64); 708 break; 709 case CRYPTO_DATA_UIO: 710 ret = crypto_update_uio(ctx->cc_provider_private, 711 ciphertext, plaintext, des_decrypt_contiguous_blocks, 712 des_copy_block64); 713 break; 714 case CRYPTO_DATA_MBLK: 715 ret = crypto_update_mp(ctx->cc_provider_private, 716 ciphertext, plaintext, des_decrypt_contiguous_blocks, 717 des_copy_block64); 718 break; 719 default: 720 ret = CRYPTO_ARGUMENTS_BAD; 721 } 722 723 if (ret == CRYPTO_SUCCESS) { 724 if (ciphertext != plaintext) 725 plaintext->cd_length = 726 plaintext->cd_offset - saved_offset; 727 } else { 728 plaintext->cd_length = saved_length; 729 } 730 plaintext->cd_offset = saved_offset; 731 732 return (ret); 733 } 734 735 /* ARGSUSED */ 736 static int 737 des_encrypt_final(crypto_ctx_t *ctx, crypto_data_t *ciphertext, 738 crypto_req_handle_t req) 739 { 740 des_ctx_t *des_ctx; 741 742 ASSERT(ctx->cc_provider_private != NULL); 743 des_ctx = ctx->cc_provider_private; 744 745 /* 746 * There must be no unprocessed plaintext. 747 * This happens if the length of the last data is 748 * not a multiple of the DES block length. 749 */ 750 if (des_ctx->dc_remainder_len > 0) 751 return (CRYPTO_DATA_LEN_RANGE); 752 753 (void) des_free_context(ctx); 754 ciphertext->cd_length = 0; 755 756 return (CRYPTO_SUCCESS); 757 } 758 759 /* ARGSUSED */ 760 static int 761 des_decrypt_final(crypto_ctx_t *ctx, crypto_data_t *plaintext, 762 crypto_req_handle_t req) 763 { 764 des_ctx_t *des_ctx; 765 766 ASSERT(ctx->cc_provider_private != NULL); 767 des_ctx = ctx->cc_provider_private; 768 769 /* 770 * There must be no unprocessed ciphertext. 771 * This happens if the length of the last ciphertext is 772 * not a multiple of the DES block length. 773 */ 774 if (des_ctx->dc_remainder_len > 0) 775 return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE); 776 777 (void) des_free_context(ctx); 778 plaintext->cd_length = 0; 779 780 return (CRYPTO_SUCCESS); 781 } 782 783 /* ARGSUSED */ 784 static int 785 des_encrypt_atomic(crypto_provider_handle_t provider, 786 crypto_session_id_t session_id, crypto_mechanism_t *mechanism, 787 crypto_key_t *key, crypto_data_t *plaintext, crypto_data_t *ciphertext, 788 crypto_spi_ctx_template_t template, crypto_req_handle_t req) 789 { 790 int ret; 791 792 des_ctx_t des_ctx; /* on the stack */ 793 des_strength_t strength; 794 off_t saved_offset; 795 size_t saved_length; 796 797 DES_ARG_INPLACE(plaintext, ciphertext); 798 799 /* 800 * Plaintext must be a multiple of the block size. 801 * This test only works for non-padded mechanisms 802 * when blocksize is 2^N. 803 */ 804 if ((plaintext->cd_length & (DES_BLOCK_LEN - 1)) != 0) 805 return (CRYPTO_DATA_LEN_RANGE); 806 807 /* return length needed to store the output */ 808 if (ciphertext->cd_length < plaintext->cd_length) { 809 ciphertext->cd_length = plaintext->cd_length; 810 return (CRYPTO_BUFFER_TOO_SMALL); 811 } 812 813 /* Check mechanism type and parameter length */ 814 switch (mechanism->cm_type) { 815 case DES_ECB_MECH_INFO_TYPE: 816 case DES_CBC_MECH_INFO_TYPE: 817 if (mechanism->cm_param_len > 0 && 818 mechanism->cm_param_len != DES_BLOCK_LEN) 819 return (CRYPTO_MECHANISM_PARAM_INVALID); 820 if (key->ck_length != DES_MINBITS) 821 return (CRYPTO_KEY_SIZE_RANGE); 822 strength = DES; 823 break; 824 case DES3_ECB_MECH_INFO_TYPE: 825 case DES3_CBC_MECH_INFO_TYPE: 826 if (mechanism->cm_param_len > 0 && 827 mechanism->cm_param_len != DES_BLOCK_LEN) 828 return (CRYPTO_MECHANISM_PARAM_INVALID); 829 if (key->ck_length != DES3_MAXBITS) 830 return (CRYPTO_KEY_SIZE_RANGE); 831 strength = DES3; 832 break; 833 default: 834 return (CRYPTO_MECHANISM_INVALID); 835 } 836 837 bzero(&des_ctx, sizeof (des_ctx_t)); 838 839 if ((ret = des_common_init_ctx(&des_ctx, template, mechanism, key, 840 strength, crypto_kmflag(req))) != CRYPTO_SUCCESS) { 841 return (ret); 842 } 843 844 saved_offset = ciphertext->cd_offset; 845 saved_length = ciphertext->cd_length; 846 847 /* 848 * Do the update on the specified input data. 849 */ 850 switch (plaintext->cd_format) { 851 case CRYPTO_DATA_RAW: 852 ret = crypto_update_iov(&des_ctx, plaintext, ciphertext, 853 des_encrypt_contiguous_blocks, des_copy_block64); 854 break; 855 case CRYPTO_DATA_UIO: 856 ret = crypto_update_uio(&des_ctx, plaintext, ciphertext, 857 des_encrypt_contiguous_blocks, des_copy_block64); 858 break; 859 case CRYPTO_DATA_MBLK: 860 ret = crypto_update_mp(&des_ctx, plaintext, ciphertext, 861 des_encrypt_contiguous_blocks, des_copy_block64); 862 break; 863 default: 864 ret = CRYPTO_ARGUMENTS_BAD; 865 } 866 867 if (des_ctx.dc_flags & PROVIDER_OWNS_KEY_SCHEDULE) { 868 bzero(des_ctx.dc_keysched, des_ctx.dc_keysched_len); 869 kmem_free(des_ctx.dc_keysched, des_ctx.dc_keysched_len); 870 } 871 872 if (ret == CRYPTO_SUCCESS) { 873 ASSERT(des_ctx.dc_remainder_len == 0); 874 if (plaintext != ciphertext) 875 ciphertext->cd_length = 876 ciphertext->cd_offset - saved_offset; 877 } else { 878 ciphertext->cd_length = saved_length; 879 } 880 ciphertext->cd_offset = saved_offset; 881 882 /* LINTED */ 883 return (ret); 884 } 885 886 /* ARGSUSED */ 887 static int 888 des_decrypt_atomic(crypto_provider_handle_t provider, 889 crypto_session_id_t session_id, crypto_mechanism_t *mechanism, 890 crypto_key_t *key, crypto_data_t *ciphertext, crypto_data_t *plaintext, 891 crypto_spi_ctx_template_t template, crypto_req_handle_t req) 892 { 893 int ret; 894 895 des_ctx_t des_ctx; /* on the stack */ 896 des_strength_t strength; 897 off_t saved_offset; 898 size_t saved_length; 899 900 DES_ARG_INPLACE(ciphertext, plaintext); 901 902 /* 903 * Ciphertext must be a multiple of the block size. 904 * This test only works for non-padded mechanisms 905 * when blocksize is 2^N. 906 */ 907 if ((ciphertext->cd_length & (DES_BLOCK_LEN - 1)) != 0) 908 return (CRYPTO_DATA_LEN_RANGE); 909 910 /* return length needed to store the output */ 911 if (plaintext->cd_length < ciphertext->cd_length) { 912 plaintext->cd_length = ciphertext->cd_length; 913 return (CRYPTO_BUFFER_TOO_SMALL); 914 } 915 916 /* Check mechanism type and parameter length */ 917 switch (mechanism->cm_type) { 918 case DES_ECB_MECH_INFO_TYPE: 919 case DES_CBC_MECH_INFO_TYPE: 920 if (mechanism->cm_param_len > 0 && 921 mechanism->cm_param_len != DES_BLOCK_LEN) 922 return (CRYPTO_MECHANISM_PARAM_INVALID); 923 if (key->ck_length != DES_MINBITS) 924 return (CRYPTO_KEY_SIZE_RANGE); 925 strength = DES; 926 break; 927 case DES3_ECB_MECH_INFO_TYPE: 928 case DES3_CBC_MECH_INFO_TYPE: 929 if (mechanism->cm_param_len > 0 && 930 mechanism->cm_param_len != DES_BLOCK_LEN) 931 return (CRYPTO_MECHANISM_PARAM_INVALID); 932 if (key->ck_length != DES3_MAXBITS) 933 return (CRYPTO_KEY_SIZE_RANGE); 934 strength = DES3; 935 break; 936 default: 937 return (CRYPTO_MECHANISM_INVALID); 938 } 939 940 bzero(&des_ctx, sizeof (des_ctx_t)); 941 942 if ((ret = des_common_init_ctx(&des_ctx, template, mechanism, key, 943 strength, crypto_kmflag(req))) != CRYPTO_SUCCESS) { 944 return (ret); 945 } 946 947 saved_offset = plaintext->cd_offset; 948 saved_length = plaintext->cd_length; 949 950 /* 951 * Do the update on the specified input data. 952 */ 953 switch (ciphertext->cd_format) { 954 case CRYPTO_DATA_RAW: 955 ret = crypto_update_iov(&des_ctx, ciphertext, plaintext, 956 des_decrypt_contiguous_blocks, des_copy_block64); 957 break; 958 case CRYPTO_DATA_UIO: 959 ret = crypto_update_uio(&des_ctx, ciphertext, plaintext, 960 des_decrypt_contiguous_blocks, des_copy_block64); 961 break; 962 case CRYPTO_DATA_MBLK: 963 ret = crypto_update_mp(&des_ctx, ciphertext, plaintext, 964 des_decrypt_contiguous_blocks, des_copy_block64); 965 break; 966 default: 967 ret = CRYPTO_ARGUMENTS_BAD; 968 } 969 970 if (des_ctx.dc_flags & PROVIDER_OWNS_KEY_SCHEDULE) { 971 bzero(des_ctx.dc_keysched, des_ctx.dc_keysched_len); 972 kmem_free(des_ctx.dc_keysched, des_ctx.dc_keysched_len); 973 } 974 975 if (ret == CRYPTO_SUCCESS) { 976 ASSERT(des_ctx.dc_remainder_len == 0); 977 if (ciphertext != plaintext) 978 plaintext->cd_length = 979 plaintext->cd_offset - saved_offset; 980 } else { 981 plaintext->cd_length = saved_length; 982 } 983 plaintext->cd_offset = saved_offset; 984 985 /* LINTED */ 986 return (ret); 987 } 988 989 /* 990 * KCF software provider context template entry points. 991 */ 992 /* ARGSUSED */ 993 static int 994 des_create_ctx_template(crypto_provider_handle_t provider, 995 crypto_mechanism_t *mechanism, crypto_key_t *key, 996 crypto_spi_ctx_template_t *tmpl, size_t *tmpl_size, crypto_req_handle_t req) 997 { 998 999 des_strength_t strength; 1000 void *keysched; 1001 size_t size; 1002 int rv; 1003 1004 switch (mechanism->cm_type) { 1005 case DES_ECB_MECH_INFO_TYPE: 1006 strength = DES; 1007 break; 1008 case DES_CBC_MECH_INFO_TYPE: 1009 strength = DES; 1010 break; 1011 case DES3_ECB_MECH_INFO_TYPE: 1012 strength = DES3; 1013 break; 1014 case DES3_CBC_MECH_INFO_TYPE: 1015 strength = DES3; 1016 break; 1017 default: 1018 return (CRYPTO_MECHANISM_INVALID); 1019 } 1020 1021 if ((keysched = des_alloc_keysched(&size, strength, 1022 crypto_kmflag(req))) == NULL) { 1023 return (CRYPTO_HOST_MEMORY); 1024 } 1025 1026 /* 1027 * Initialize key schedule. Key length information is stored 1028 * in the key. 1029 */ 1030 if ((rv = init_keysched(key, keysched, strength)) != CRYPTO_SUCCESS) { 1031 bzero(keysched, size); 1032 kmem_free(keysched, size); 1033 return (rv); 1034 } 1035 1036 *tmpl = keysched; 1037 *tmpl_size = size; 1038 1039 return (CRYPTO_SUCCESS); 1040 } 1041 1042 /* ARGSUSED */ 1043 static int 1044 des_free_context(crypto_ctx_t *ctx) 1045 { 1046 des_ctx_t *des_ctx = ctx->cc_provider_private; 1047 1048 if (des_ctx != NULL) { 1049 if (des_ctx->dc_flags & PROVIDER_OWNS_KEY_SCHEDULE) { 1050 ASSERT(des_ctx->dc_keysched_len != 0); 1051 bzero(des_ctx->dc_keysched, des_ctx->dc_keysched_len); 1052 kmem_free(des_ctx->dc_keysched, 1053 des_ctx->dc_keysched_len); 1054 } 1055 crypto_free_mode_ctx(des_ctx); 1056 ctx->cc_provider_private = NULL; 1057 } 1058 1059 return (CRYPTO_SUCCESS); 1060 } 1061 1062 /* 1063 * Pass it to des_keycheck() which will 1064 * fix it (parity bits), and check if the fixed key is weak. 1065 */ 1066 /* ARGSUSED */ 1067 static int 1068 des_key_check(crypto_provider_handle_t pd, crypto_mechanism_t *mech, 1069 crypto_key_t *key) 1070 { 1071 int expectedkeylen; 1072 des_strength_t strength; 1073 uint8_t keydata[DES3_MAX_KEY_LEN]; 1074 1075 if ((mech == NULL) || (key == NULL)) 1076 return (CRYPTO_ARGUMENTS_BAD); 1077 1078 switch (mech->cm_type) { 1079 case DES_ECB_MECH_INFO_TYPE: 1080 case DES_CBC_MECH_INFO_TYPE: 1081 expectedkeylen = DES_MINBITS; 1082 strength = DES; 1083 break; 1084 case DES3_ECB_MECH_INFO_TYPE: 1085 case DES3_CBC_MECH_INFO_TYPE: 1086 expectedkeylen = DES3_MAXBITS; 1087 strength = DES3; 1088 break; 1089 default: 1090 return (CRYPTO_MECHANISM_INVALID); 1091 } 1092 1093 if (key->ck_format != CRYPTO_KEY_RAW) 1094 return (CRYPTO_KEY_TYPE_INCONSISTENT); 1095 1096 if (key->ck_length != expectedkeylen) 1097 return (CRYPTO_KEY_SIZE_RANGE); 1098 1099 bcopy(key->ck_data, keydata, CRYPTO_BITS2BYTES(expectedkeylen)); 1100 1101 if (des_keycheck(keydata, strength, key->ck_data) == B_FALSE) 1102 return (CRYPTO_WEAK_KEY); 1103 1104 return (CRYPTO_SUCCESS); 1105 } 1106 1107 /* ARGSUSED */ 1108 static int 1109 des_common_init_ctx(des_ctx_t *des_ctx, crypto_spi_ctx_template_t *template, 1110 crypto_mechanism_t *mechanism, crypto_key_t *key, des_strength_t strength, 1111 int kmflag) 1112 { 1113 int rv = CRYPTO_SUCCESS; 1114 1115 void *keysched; 1116 size_t size; 1117 1118 if (template == NULL) { 1119 if ((keysched = des_alloc_keysched(&size, strength, 1120 kmflag)) == NULL) 1121 return (CRYPTO_HOST_MEMORY); 1122 /* 1123 * Initialize key schedule. 1124 * Key length is stored in the key. 1125 */ 1126 if ((rv = init_keysched(key, keysched, 1127 strength)) != CRYPTO_SUCCESS) 1128 kmem_free(keysched, size); 1129 1130 des_ctx->dc_flags |= PROVIDER_OWNS_KEY_SCHEDULE; 1131 des_ctx->dc_keysched_len = size; 1132 } else { 1133 keysched = template; 1134 } 1135 des_ctx->dc_keysched = keysched; 1136 1137 if (strength == DES3) { 1138 des_ctx->dc_flags |= DES3_STRENGTH; 1139 } 1140 1141 switch (mechanism->cm_type) { 1142 case DES_CBC_MECH_INFO_TYPE: 1143 case DES3_CBC_MECH_INFO_TYPE: 1144 rv = cbc_init_ctx((cbc_ctx_t *)des_ctx, mechanism->cm_param, 1145 mechanism->cm_param_len, DES_BLOCK_LEN, des_copy_block64); 1146 break; 1147 case DES_ECB_MECH_INFO_TYPE: 1148 case DES3_ECB_MECH_INFO_TYPE: 1149 des_ctx->dc_flags |= ECB_MODE; 1150 } 1151 1152 if (rv != CRYPTO_SUCCESS) { 1153 if (des_ctx->dc_flags & PROVIDER_OWNS_KEY_SCHEDULE) { 1154 bzero(keysched, size); 1155 kmem_free(keysched, size); 1156 } 1157 } 1158 1159 return (rv); 1160 } 1161