usr/src/uts/common/crypto/io/blowfish.c

   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  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*
  27  * Blowfish provider for the Kernel Cryptographic Framework (KCF)
  28  */
  29
  30 #include <sys/types.h>
  31 #include <sys/systm.h>
  32 #include <sys/modctl.h>
  33 #include <sys/cmn_err.h>
  34 #include <sys/ddi.h>
  35 #include <sys/crypto/common.h>
  36 #include <sys/crypto/spi.h>
  37 #include <sys/sysmacros.h>
  38 #include <sys/strsun.h>
  39 #include <sys/note.h>
  40 #include <modes/modes.h>
  41 #include <blowfish/blowfish_impl.h>
  42
  43 extern struct mod_ops mod_cryptoops;
  44
  45 /*
  46  * Module linkage information for the kernel.
  47  */
  48 static struct modlcrypto modlcrypto = {
  49         &mod_cryptoops,
  50         "Blowfish Kernel SW Provider"
  51 };
  52
  53 static struct modlinkage modlinkage = {
  54         MODREV_1,
  55         (void *)&modlcrypto,
  56         NULL
  57 };
  58
  59 /*
  60  * CSPI information (entry points, provider info, etc.)
  61  */
  62 typedef enum blowfish_mech_type {
  63         BLOWFISH_ECB_MECH_INFO_TYPE,            /* SUN_CKM_BLOWFISH_ECB */
  64         BLOWFISH_CBC_MECH_INFO_TYPE             /* SUN_CKM_BLOWFISH_CBC */
  65 } blowfish_mech_type_t;
  66
  67
  68 #define BLOWFISH_COPY_BLOCK(src, dst) \
  69         (dst)[0] = (src)[0]; \
  70         (dst)[1] = (src)[1]; \
  71         (dst)[2] = (src)[2]; \
  72         (dst)[3] = (src)[3]; \
  73         (dst)[4] = (src)[4]; \
  74         (dst)[5] = (src)[5]; \
  75         (dst)[6] = (src)[6]; \
  76         (dst)[7] = (src)[7]
  77
  78 #define BLOWFISH_XOR_BLOCK(src, dst) \
  79         (dst)[0] ^= (src)[0]; \
  80         (dst)[1] ^= (src)[1]; \
  81         (dst)[2] ^= (src)[2]; \
  82         (dst)[3] ^= (src)[3]; \
  83         (dst)[4] ^= (src)[4]; \
  84         (dst)[5] ^= (src)[5]; \
  85         (dst)[6] ^= (src)[6]; \
  86         (dst)[7] ^= (src)[7]
  87
  88 /*
  89  * Mechanism info structure passed to KCF during registration.
  90  */
  91
  92 static crypto_mech_info_t blowfish_mech_info_tab[] = {
  93         /* BLOWFISH_ECB */
  94         {SUN_CKM_BLOWFISH_ECB, BLOWFISH_ECB_MECH_INFO_TYPE,
  95             CRYPTO_FG_ENCRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
  96             CRYPTO_FG_DECRYPT | CRYPTO_FG_DECRYPT_ATOMIC,
  97             BLOWFISH_MINBITS, BLOWFISH_MAXBITS, CRYPTO_KEYSIZE_UNIT_IN_BITS},
  98         /* BLOWFISH_CBC */
  99         {SUN_CKM_BLOWFISH_CBC, BLOWFISH_CBC_MECH_INFO_TYPE,
 100             CRYPTO_FG_ENCRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
 101             CRYPTO_FG_DECRYPT | CRYPTO_FG_DECRYPT_ATOMIC,
 102             BLOWFISH_MINBITS, BLOWFISH_MAXBITS, CRYPTO_KEYSIZE_UNIT_IN_BITS}
 103 };
 104
 105 #define BLOWFISH_VALID_MECH(mech)                               \
 106         (((mech)->cm_type == BLOWFISH_ECB_MECH_INFO_TYPE ||             \
 107         (mech)->cm_type == BLOWFISH_CBC_MECH_INFO_TYPE) ? 1 : 0)
 108
 109 /* operations are in-place if the output buffer is NULL */
 110 #define BLOWFISH_ARG_INPLACE(input, output)                     \
 111         if ((output) == NULL)                                   \
 112                 (output) = (input);
 113
 114 static void blowfish_provider_status(crypto_provider_handle_t, uint_t *);
 115
 116 static crypto_control_ops_t blowfish_control_ops = {
 117         blowfish_provider_status
 118 };
 119
 120 static int blowfish_common_init(crypto_ctx_t *, crypto_mechanism_t *,
 121     crypto_key_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
 122 static int blowfish_common_init_ctx(blowfish_ctx_t *,
 123     crypto_spi_ctx_template_t *, crypto_mechanism_t *, crypto_key_t *, int);
 124 static int blowfish_encrypt_final(crypto_ctx_t *, crypto_data_t *,
 125     crypto_req_handle_t);
 126 static int blowfish_decrypt_final(crypto_ctx_t *, crypto_data_t *,
 127     crypto_req_handle_t);
 128
 129 static int blowfish_encrypt(crypto_ctx_t *, crypto_data_t *, crypto_data_t *,
 130     crypto_req_handle_t);
 131 static int blowfish_encrypt_update(crypto_ctx_t *, crypto_data_t *,
 132     crypto_data_t *, crypto_req_handle_t);
 133 static int blowfish_encrypt_atomic(crypto_provider_handle_t,
 134     crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
 135     crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
 136
 137 static int blowfish_decrypt(crypto_ctx_t *, crypto_data_t *, crypto_data_t *,
 138     crypto_req_handle_t);
 139 static int blowfish_decrypt_update(crypto_ctx_t *, crypto_data_t *,
 140     crypto_data_t *, crypto_req_handle_t);
 141 static int blowfish_decrypt_atomic(crypto_provider_handle_t,
 142     crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
 143     crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
 144
 145 static crypto_cipher_ops_t blowfish_cipher_ops = {
 146         blowfish_common_init,
 147         blowfish_encrypt,
 148         blowfish_encrypt_update,
 149         blowfish_encrypt_final,
 150         blowfish_encrypt_atomic,
 151         blowfish_common_init,
 152         blowfish_decrypt,
 153         blowfish_decrypt_update,
 154         blowfish_decrypt_final,
 155         blowfish_decrypt_atomic
 156 };
 157
 158 static int blowfish_create_ctx_template(crypto_provider_handle_t,
 159     crypto_mechanism_t *, crypto_key_t *, crypto_spi_ctx_template_t *,
 160     size_t *, crypto_req_handle_t);
 161 static int blowfish_free_context(crypto_ctx_t *);
 162
 163 static crypto_ctx_ops_t blowfish_ctx_ops = {
 164         blowfish_create_ctx_template,
 165         blowfish_free_context
 166 };
 167
 168 static crypto_ops_t blowfish_crypto_ops = {
 169         &blowfish_control_ops,
 170         NULL,
 171         &blowfish_cipher_ops,
 172         NULL,
 173         NULL,
 174         NULL,
 175         NULL,
 176         NULL,
 177         NULL,
 178         NULL,
 179         NULL,
 180         NULL,
 181         NULL,
 182         &blowfish_ctx_ops
 183 };
 184
 185 static crypto_provider_info_t blowfish_prov_info = {
 186         CRYPTO_SPI_VERSION_1,
 187         "Blowfish Software Provider",
 188         CRYPTO_SW_PROVIDER,
 189         {&modlinkage},
 190         NULL,
 191         &blowfish_crypto_ops,
 192         sizeof (blowfish_mech_info_tab)/sizeof (crypto_mech_info_t),
 193         blowfish_mech_info_tab
 194 };
 195
 196
 197 static crypto_kcf_provider_handle_t blowfish_prov_handle = 0;
 198
 199 int
 200 _init(void)
 201 {
 202         int ret;
 203
 204         if ((ret = mod_install(&modlinkage)) != 0)
 205                 return (ret);
 206
 207         /* Register with KCF.  If the registration fails, remove the module. */
 208         if (crypto_register_provider(&blowfish_prov_info,
 209             &blowfish_prov_handle)) {
 210                 (void) mod_remove(&modlinkage);
 211                 return (EACCES);
 212         }
 213
 214         return (0);
 215 }
 216
 217 int
 218 _fini(void)
 219 {
 220         /* Unregister from KCF if module is registered */
 221         if (blowfish_prov_handle != 0) {
 222                 if (crypto_unregister_provider(blowfish_prov_handle))
 223                         return (EBUSY);
 224
 225                 blowfish_prov_handle = 0;
 226         }
 227
 228         return (mod_remove(&modlinkage));
 229 }
 230
 231 int
 232 _info(struct modinfo *modinfop)
 233 {
 234         return (mod_info(&modlinkage, modinfop));
 235 }
 236
 237 /*
 238  * Initialize key schedules for blowfish
 239  */
 240 static int
 241 init_keysched(crypto_key_t *key, void *keysched)
 242 {
 243         /*
 244          * Only keys by value are supported by this module.
 245          */
 246         switch (key->ck_format) {
 247         case CRYPTO_KEY_RAW:
 248                 if (key->ck_length < BLOWFISH_MINBITS ||
 249                     key->ck_length > BLOWFISH_MAXBITS) {
 250                         return (CRYPTO_KEY_SIZE_RANGE);
 251                 }
 252                 break;
 253         default:
 254                 return (CRYPTO_KEY_TYPE_INCONSISTENT);
 255         }
 256
 257         blowfish_init_keysched(key->ck_data, key->ck_length, keysched);
 258         return (CRYPTO_SUCCESS);
 259 }
 260
 261 /*
 262  * KCF software provider control entry points.
 263  */
 264 /* ARGSUSED */
 265 static void
 266 blowfish_provider_status(crypto_provider_handle_t provider, uint_t *status)
 267 {
 268         *status = CRYPTO_PROVIDER_READY;
 269 }
 270
 271 /*
 272  * KCF software provider encrypt entry points.
 273  */
 274 static int
 275 blowfish_common_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
 276     crypto_key_t *key, crypto_spi_ctx_template_t template,
 277     crypto_req_handle_t req)
 278 {
 279         blowfish_ctx_t *blowfish_ctx;
 280         int rv;
 281         int kmflag;
 282
 283         /*
 284          * Only keys by value are supported by this module.
 285          */
 286         if (key->ck_format != CRYPTO_KEY_RAW) {
 287                 return (CRYPTO_KEY_TYPE_INCONSISTENT);
 288         }
 289
 290         if (!BLOWFISH_VALID_MECH(mechanism))
 291                 return (CRYPTO_MECHANISM_INVALID);
 292
 293         if (mechanism->cm_param != NULL &&
 294             mechanism->cm_param_len != BLOWFISH_BLOCK_LEN)
 295                 return (CRYPTO_MECHANISM_PARAM_INVALID);
 296
 297         kmflag = crypto_kmflag(req);
 298         switch (mechanism->cm_type) {
 299         case BLOWFISH_ECB_MECH_INFO_TYPE:
 300                 blowfish_ctx = ecb_alloc_ctx(kmflag);
 301                 break;
 302         case BLOWFISH_CBC_MECH_INFO_TYPE:
 303                 blowfish_ctx = cbc_alloc_ctx(kmflag);
 304                 break;
 305         }
 306         if (blowfish_ctx == NULL)
 307                 return (CRYPTO_HOST_MEMORY);
 308
 309         rv = blowfish_common_init_ctx(blowfish_ctx, template, mechanism,
 310             key, kmflag);
 311         if (rv != CRYPTO_SUCCESS) {
 312                 crypto_free_mode_ctx(blowfish_ctx);
 313                 return (rv);
 314         }
 315
 316         ctx->cc_provider_private = blowfish_ctx;
 317
 318         return (CRYPTO_SUCCESS);
 319 }
 320
 321 static void
 322 blowfish_copy_block64(uint8_t *in, uint64_t *out)
 323 {
 324         if (IS_P2ALIGNED(in, sizeof (uint64_t))) {
 325                 /* LINTED: pointer alignment */
 326                 out[0] = *(uint64_t *)&in[0];
 327         } else {
 328                 uint8_t *iv8 = (uint8_t *)&out[0];
 329
 330                 BLOWFISH_COPY_BLOCK(in, iv8);
 331         }
 332 }
 333
 334 /* ARGSUSED */
 335 static int
 336 blowfish_encrypt(crypto_ctx_t *ctx, crypto_data_t *plaintext,
 337     crypto_data_t *ciphertext, crypto_req_handle_t req)
 338 {
 339         int ret;
 340
 341         blowfish_ctx_t *blowfish_ctx;
 342
 343         /*
 344          * Plaintext must be a multiple of blowfish block size.
 345          * This test only works for non-padded mechanisms
 346          * when blocksize is 2^N.
 347          */
 348         if ((plaintext->cd_length & (BLOWFISH_BLOCK_LEN - 1)) != 0)
 349                 return (CRYPTO_DATA_LEN_RANGE);
 350
 351         ASSERT(ctx->cc_provider_private != NULL);
 352         blowfish_ctx = ctx->cc_provider_private;
 353
 354         BLOWFISH_ARG_INPLACE(plaintext, ciphertext);
 355
 356         /*
 357          * We need to just return the length needed to store the output.
 358          * We should not destroy the context for the following case.
 359          */
 360         if (ciphertext->cd_length < plaintext->cd_length) {
 361                 ciphertext->cd_length = plaintext->cd_length;
 362                 return (CRYPTO_BUFFER_TOO_SMALL);
 363         }
 364
 365         /*
 366          * Do an update on the specified input data.
 367          */
 368         ret = blowfish_encrypt_update(ctx, plaintext, ciphertext, req);
 369         ASSERT(blowfish_ctx->bc_remainder_len  == 0);
 370         (void) blowfish_free_context(ctx);
 371
 372         /* LINTED */
 373         return (ret);
 374 }
 375
 376 /* ARGSUSED */
 377 static int
 378 blowfish_decrypt(crypto_ctx_t *ctx, crypto_data_t *ciphertext,
 379     crypto_data_t *plaintext, crypto_req_handle_t req)
 380 {
 381         int ret;
 382
 383         blowfish_ctx_t *blowfish_ctx;
 384
 385         /*
 386          * Ciphertext must be a multiple of blowfish block size.
 387          * This test only works for non-padded mechanisms
 388          * when blocksize is 2^N.
 389          */
 390         if ((ciphertext->cd_length & (BLOWFISH_BLOCK_LEN - 1)) != 0)
 391                 return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE);
 392
 393         ASSERT(ctx->cc_provider_private != NULL);
 394         blowfish_ctx = ctx->cc_provider_private;
 395
 396         BLOWFISH_ARG_INPLACE(ciphertext, plaintext);
 397
 398         /*
 399          * We need to just return the length needed to store the output.
 400          * We should not destroy the context for the following case.
 401          */
 402         if (plaintext->cd_length < ciphertext->cd_length) {
 403                 plaintext->cd_length = ciphertext->cd_length;
 404                 return (CRYPTO_BUFFER_TOO_SMALL);
 405         }
 406
 407         /*
 408          * Do an update on the specified input data.
 409          */
 410         ret = blowfish_decrypt_update(ctx, ciphertext, plaintext, req);
 411         ASSERT(blowfish_ctx->bc_remainder_len == 0);
 412         (void) blowfish_free_context(ctx);
 413
 414         /* LINTED */
 415         return (ret);
 416 }
 417
 418 /* ARGSUSED */
 419 static int
 420 blowfish_encrypt_update(crypto_ctx_t *ctx, crypto_data_t *plaintext,
 421     crypto_data_t *ciphertext, crypto_req_handle_t req)
 422 {
 423         off_t saved_offset;
 424         size_t saved_length, out_len;
 425         int ret = CRYPTO_SUCCESS;
 426
 427         ASSERT(ctx->cc_provider_private != NULL);
 428
 429         BLOWFISH_ARG_INPLACE(plaintext, ciphertext);
 430
 431         /* compute number of bytes that will hold the ciphertext */
 432         out_len =
 433             ((blowfish_ctx_t *)ctx->cc_provider_private)->bc_remainder_len;
 434         out_len += plaintext->cd_length;
 435         out_len &= ~(BLOWFISH_BLOCK_LEN - 1);
 436
 437         /* return length needed to store the output */
 438         if (ciphertext->cd_length < out_len) {
 439                 ciphertext->cd_length = out_len;
 440                 return (CRYPTO_BUFFER_TOO_SMALL);
 441         }
 442
 443         saved_offset = ciphertext->cd_offset;
 444         saved_length = ciphertext->cd_length;
 445
 446         /*
 447          * Do the blowfish update on the specified input data.
 448          */
 449         switch (plaintext->cd_format) {
 450         case CRYPTO_DATA_RAW:
 451                 ret = crypto_update_iov(ctx->cc_provider_private,
 452                     plaintext, ciphertext, blowfish_encrypt_contiguous_blocks,
 453                     blowfish_copy_block64);
 454                 break;
 455         case CRYPTO_DATA_UIO:
 456                 ret = crypto_update_uio(ctx->cc_provider_private,
 457                     plaintext, ciphertext, blowfish_encrypt_contiguous_blocks,
 458                     blowfish_copy_block64);
 459                 break;
 460         case CRYPTO_DATA_MBLK:
 461                 ret = crypto_update_mp(ctx->cc_provider_private,
 462                     plaintext, ciphertext, blowfish_encrypt_contiguous_blocks,
 463                     blowfish_copy_block64);
 464                 break;
 465         default:
 466                 ret = CRYPTO_ARGUMENTS_BAD;
 467         }
 468
 469         if (ret == CRYPTO_SUCCESS) {
 470                 if (plaintext != ciphertext)
 471                         ciphertext->cd_length =
 472                             ciphertext->cd_offset - saved_offset;
 473         } else {
 474                 ciphertext->cd_length = saved_length;
 475         }
 476         ciphertext->cd_offset = saved_offset;
 477
 478         return (ret);
 479 }
 480
 481 /* ARGSUSED */
 482 static int
 483 blowfish_decrypt_update(crypto_ctx_t *ctx, crypto_data_t *ciphertext,
 484     crypto_data_t *plaintext, crypto_req_handle_t req)
 485 {
 486         off_t saved_offset;
 487         size_t saved_length, out_len;
 488         int ret = CRYPTO_SUCCESS;
 489
 490         ASSERT(ctx->cc_provider_private != NULL);
 491
 492         BLOWFISH_ARG_INPLACE(ciphertext, plaintext);
 493
 494         /* compute number of bytes that will hold the plaintext */
 495         out_len =
 496             ((blowfish_ctx_t *)ctx->cc_provider_private)->bc_remainder_len;
 497         out_len += ciphertext->cd_length;
 498         out_len &= ~(BLOWFISH_BLOCK_LEN - 1);
 499
 500         /* return length needed to store the output */
 501         if (plaintext->cd_length < out_len) {
 502                 plaintext->cd_length = out_len;
 503                 return (CRYPTO_BUFFER_TOO_SMALL);
 504         }
 505
 506         saved_offset = plaintext->cd_offset;
 507         saved_length = plaintext->cd_length;
 508
 509         /*
 510          * Do the blowfish update on the specified input data.
 511          */
 512         switch (ciphertext->cd_format) {
 513         case CRYPTO_DATA_RAW:
 514                 ret = crypto_update_iov(ctx->cc_provider_private,
 515                     ciphertext, plaintext, blowfish_decrypt_contiguous_blocks,
 516                     blowfish_copy_block64);
 517                 break;
 518         case CRYPTO_DATA_UIO:
 519                 ret = crypto_update_uio(ctx->cc_provider_private,
 520                     ciphertext, plaintext, blowfish_decrypt_contiguous_blocks,
 521                     blowfish_copy_block64);
 522                 break;
 523         case CRYPTO_DATA_MBLK:
 524                 ret = crypto_update_mp(ctx->cc_provider_private,
 525                     ciphertext, plaintext, blowfish_decrypt_contiguous_blocks,
 526                     blowfish_copy_block64);
 527                 break;
 528         default:
 529                 ret = CRYPTO_ARGUMENTS_BAD;
 530         }
 531
 532         if (ret == CRYPTO_SUCCESS) {
 533                 if (ciphertext != plaintext)
 534                         plaintext->cd_length =
 535                             plaintext->cd_offset - saved_offset;
 536         } else {
 537                 plaintext->cd_length = saved_length;
 538         }
 539         plaintext->cd_offset = saved_offset;
 540
 541         return (ret);
 542 }
 543
 544 /* ARGSUSED */
 545 static int
 546 blowfish_encrypt_final(crypto_ctx_t *ctx, crypto_data_t *data,
 547     crypto_req_handle_t req)
 548 {
 549         blowfish_ctx_t *blowfish_ctx;
 550
 551         ASSERT(ctx->cc_provider_private != NULL);
 552         blowfish_ctx = ctx->cc_provider_private;
 553
 554         /*
 555          * There must be no unprocessed data.
 556          * This happens if the length of the last data is
 557          * not a multiple of the BLOWFISH block length.
 558          */
 559         if (blowfish_ctx->bc_remainder_len > 0)
 560                 return (CRYPTO_DATA_LEN_RANGE);
 561
 562         (void) blowfish_free_context(ctx);
 563         data->cd_length = 0;
 564
 565         return (CRYPTO_SUCCESS);
 566 }
 567
 568 /* ARGSUSED */
 569 static int
 570 blowfish_decrypt_final(crypto_ctx_t *ctx, crypto_data_t *data,
 571     crypto_req_handle_t req)
 572 {
 573         blowfish_ctx_t *blowfish_ctx;
 574
 575         ASSERT(ctx->cc_provider_private != NULL);
 576         blowfish_ctx = ctx->cc_provider_private;
 577
 578         /*
 579          * There must be no unprocessed ciphertext.
 580          * This happens if the length of the last ciphertext is
 581          * not a multiple of the BLOWFISH block length.
 582          */
 583         if (blowfish_ctx->bc_remainder_len > 0)
 584                 return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE);
 585
 586         (void) blowfish_free_context(ctx);
 587         data->cd_length = 0;
 588
 589         return (CRYPTO_SUCCESS);
 590 }
 591
 592 /* ARGSUSED */
 593 static int
 594 blowfish_encrypt_atomic(crypto_provider_handle_t provider,
 595     crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
 596     crypto_key_t *key, crypto_data_t *plaintext, crypto_data_t *ciphertext,
 597     crypto_spi_ctx_template_t template, crypto_req_handle_t req)
 598 {
 599         blowfish_ctx_t blowfish_ctx;    /* on the stack */
 600         off_t saved_offset;
 601         size_t saved_length;
 602         int ret;
 603
 604         BLOWFISH_ARG_INPLACE(plaintext, ciphertext);
 605
 606         /*
 607          * Plaintext must be a multiple of blowfish block size.
 608          * This test only works for non-padded mechanisms
 609          * when blocksize is 2^N.
 610          */
 611         if ((plaintext->cd_length & (BLOWFISH_BLOCK_LEN - 1)) != 0)
 612                 return (CRYPTO_DATA_LEN_RANGE);
 613
 614         /* return length needed to store the output */
 615         if (ciphertext->cd_length < plaintext->cd_length) {
 616                 ciphertext->cd_length = plaintext->cd_length;
 617                 return (CRYPTO_BUFFER_TOO_SMALL);
 618         }
 619
 620         if (!BLOWFISH_VALID_MECH(mechanism))
 621                 return (CRYPTO_MECHANISM_INVALID);
 622
 623         if (mechanism->cm_param_len != 0 &&
 624             mechanism->cm_param_len != BLOWFISH_BLOCK_LEN)
 625                 return (CRYPTO_MECHANISM_PARAM_INVALID);
 626
 627         bzero(&blowfish_ctx, sizeof (blowfish_ctx_t));
 628
 629         ret = blowfish_common_init_ctx(&blowfish_ctx, template, mechanism,
 630             key, crypto_kmflag(req));
 631         if (ret != CRYPTO_SUCCESS)
 632                 return (ret);
 633
 634         saved_offset = ciphertext->cd_offset;
 635         saved_length = ciphertext->cd_length;
 636
 637         /*
 638          * Do an update on the specified input data.
 639          */
 640         switch (plaintext->cd_format) {
 641         case CRYPTO_DATA_RAW:
 642                 ret = crypto_update_iov(&blowfish_ctx,
 643                     plaintext, ciphertext, blowfish_encrypt_contiguous_blocks,
 644                     blowfish_copy_block64);
 645                 break;
 646         case CRYPTO_DATA_UIO:
 647                 ret = crypto_update_uio(&blowfish_ctx,
 648                     plaintext, ciphertext, blowfish_encrypt_contiguous_blocks,
 649                     blowfish_copy_block64);
 650                 break;
 651         case CRYPTO_DATA_MBLK:
 652                 ret = crypto_update_mp((void *)&blowfish_ctx,
 653                     plaintext, ciphertext, blowfish_encrypt_contiguous_blocks,
 654                     blowfish_copy_block64);
 655                 break;
 656         default:
 657                 ret = CRYPTO_ARGUMENTS_BAD;
 658         }
 659
 660         if (blowfish_ctx.bc_flags & PROVIDER_OWNS_KEY_SCHEDULE) {
 661                 bzero(blowfish_ctx.bc_keysched, blowfish_ctx.bc_keysched_len);
 662                 kmem_free(blowfish_ctx.bc_keysched,
 663                     blowfish_ctx.bc_keysched_len);
 664         }
 665
 666         if (ret == CRYPTO_SUCCESS) {
 667                 ASSERT(blowfish_ctx.bc_remainder_len == 0);
 668                 if (plaintext != ciphertext)
 669                         ciphertext->cd_length =
 670                             ciphertext->cd_offset - saved_offset;
 671         } else {
 672                 ciphertext->cd_length = saved_length;
 673         }
 674         ciphertext->cd_offset = saved_offset;
 675
 676         return (ret);
 677 }
 678
 679 /* ARGSUSED */
 680 static int
 681 blowfish_decrypt_atomic(crypto_provider_handle_t provider,
 682     crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
 683     crypto_key_t *key, crypto_data_t *ciphertext, crypto_data_t *plaintext,
 684     crypto_spi_ctx_template_t template, crypto_req_handle_t req)
 685 {
 686         blowfish_ctx_t blowfish_ctx;    /* on the stack */
 687         off_t saved_offset;
 688         size_t saved_length;
 689         int ret;
 690
 691         BLOWFISH_ARG_INPLACE(ciphertext, plaintext);
 692
 693         /*
 694          * Ciphertext must be a multiple of blowfish block size.
 695          * This test only works for non-padded mechanisms
 696          * when blocksize is 2^N.
 697          */
 698         if ((ciphertext->cd_length & (BLOWFISH_BLOCK_LEN - 1)) != 0)
 699                 return (CRYPTO_DATA_LEN_RANGE);
 700
 701         /* return length needed to store the output */
 702         if (plaintext->cd_length < ciphertext->cd_length) {
 703                 plaintext->cd_length = ciphertext->cd_length;
 704                 return (CRYPTO_BUFFER_TOO_SMALL);
 705         }
 706
 707         if (!BLOWFISH_VALID_MECH(mechanism))
 708                 return (CRYPTO_MECHANISM_INVALID);
 709
 710         if (mechanism->cm_param_len != 0 &&
 711             mechanism->cm_param_len != BLOWFISH_BLOCK_LEN)
 712                 return (CRYPTO_MECHANISM_PARAM_INVALID);
 713
 714         bzero(&blowfish_ctx, sizeof (blowfish_ctx_t));
 715
 716         ret = blowfish_common_init_ctx(&blowfish_ctx, template, mechanism,
 717             key, crypto_kmflag(req));
 718         if (ret != CRYPTO_SUCCESS)
 719                 return (ret);
 720
 721         saved_offset = plaintext->cd_offset;
 722         saved_length = plaintext->cd_length;
 723
 724         /*
 725          * Do an update on the specified input data.
 726          */
 727         switch (ciphertext->cd_format) {
 728         case CRYPTO_DATA_RAW:
 729                 ret = crypto_update_iov(&blowfish_ctx,
 730                     ciphertext, plaintext, blowfish_decrypt_contiguous_blocks,
 731                     blowfish_copy_block64);
 732                 break;
 733         case CRYPTO_DATA_UIO:
 734                 ret = crypto_update_uio(&blowfish_ctx,
 735                     ciphertext, plaintext, blowfish_decrypt_contiguous_blocks,
 736                     blowfish_copy_block64);
 737                 break;
 738         case CRYPTO_DATA_MBLK:
 739                 ret = crypto_update_mp(&blowfish_ctx,
 740                     ciphertext, plaintext, blowfish_decrypt_contiguous_blocks,
 741                     blowfish_copy_block64);
 742                 break;
 743         default:
 744                 ret = CRYPTO_ARGUMENTS_BAD;
 745         }
 746
 747         if (blowfish_ctx.bc_flags & PROVIDER_OWNS_KEY_SCHEDULE) {
 748                 bzero(blowfish_ctx.bc_keysched, blowfish_ctx.bc_keysched_len);
 749                 kmem_free(blowfish_ctx.bc_keysched,
 750                     blowfish_ctx.bc_keysched_len);
 751         }
 752
 753         if (ret == CRYPTO_SUCCESS) {
 754                 ASSERT(blowfish_ctx.bc_remainder_len == 0);
 755                 if (ciphertext != plaintext)
 756                         plaintext->cd_length =
 757                             plaintext->cd_offset - saved_offset;
 758         } else {
 759                 plaintext->cd_length = saved_length;
 760         }
 761         plaintext->cd_offset = saved_offset;
 762
 763         return (ret);
 764 }
 765
 766 /*
 767  * KCF software provider context template entry points.
 768  */
 769 /* ARGSUSED */
 770 static int
 771 blowfish_create_ctx_template(crypto_provider_handle_t provider,
 772     crypto_mechanism_t *mechanism, crypto_key_t *key,
 773     crypto_spi_ctx_template_t *tmpl, size_t *tmpl_size, crypto_req_handle_t req)
 774 {
 775         void *keysched;
 776         size_t size;
 777         int rv;
 778
 779         if (!BLOWFISH_VALID_MECH(mechanism))
 780                 return (CRYPTO_MECHANISM_INVALID);
 781
 782         if ((keysched = blowfish_alloc_keysched(&size,
 783             crypto_kmflag(req))) == NULL) {
 784                 return (CRYPTO_HOST_MEMORY);
 785         }
 786
 787         /*
 788          * Initialize key schedule.  Key length information is stored
 789          * in the key.
 790          */
 791         if ((rv = init_keysched(key, keysched)) != CRYPTO_SUCCESS) {
 792                 bzero(keysched, size);
 793                 kmem_free(keysched, size);
 794                 return (rv);
 795         }
 796
 797         *tmpl = keysched;
 798         *tmpl_size = size;
 799
 800         return (CRYPTO_SUCCESS);
 801 }
 802
 803 /* ARGSUSED */
 804 static int
 805 blowfish_free_context(crypto_ctx_t *ctx)
 806 {
 807         blowfish_ctx_t *blowfish_ctx = ctx->cc_provider_private;
 808
 809         if (blowfish_ctx != NULL) {
 810                 if (blowfish_ctx->bc_flags & PROVIDER_OWNS_KEY_SCHEDULE) {
 811                         ASSERT(blowfish_ctx->bc_keysched_len != 0);
 812                         bzero(blowfish_ctx->bc_keysched,
 813                             blowfish_ctx->bc_keysched_len);
 814                         kmem_free(blowfish_ctx->bc_keysched,
 815                             blowfish_ctx->bc_keysched_len);
 816                 }
 817                 crypto_free_mode_ctx(blowfish_ctx);
 818                 ctx->cc_provider_private = NULL;
 819         }
 820
 821         return (CRYPTO_SUCCESS);
 822 }
 823
 824 /* ARGSUSED */
 825 static int
 826 blowfish_common_init_ctx(blowfish_ctx_t *blowfish_ctx,
 827     crypto_spi_ctx_template_t *template, crypto_mechanism_t *mechanism,
 828     crypto_key_t *key, int kmflag)
 829 {
 830         int rv = CRYPTO_SUCCESS;
 831
 832         void *keysched;
 833         size_t size;
 834
 835         if (template == NULL) {
 836                 if ((keysched = blowfish_alloc_keysched(&size, kmflag)) == NULL)
 837                         return (CRYPTO_HOST_MEMORY);
 838                 /*
 839                  * Initialize key schedule.
 840                  * Key length is stored in the key.
 841                  */
 842                 if ((rv = init_keysched(key, keysched)) != CRYPTO_SUCCESS)
 843                         kmem_free(keysched, size);
 844
 845                 blowfish_ctx->bc_flags |= PROVIDER_OWNS_KEY_SCHEDULE;
 846                 blowfish_ctx->bc_keysched_len = size;
 847         } else {
 848                 keysched = template;
 849         }
 850         blowfish_ctx->bc_keysched = keysched;
 851
 852         switch (mechanism->cm_type) {
 853         case BLOWFISH_CBC_MECH_INFO_TYPE:
 854                 rv = cbc_init_ctx((cbc_ctx_t *)blowfish_ctx,
 855                     mechanism->cm_param, mechanism->cm_param_len,
 856                     BLOWFISH_BLOCK_LEN, blowfish_copy_block64);
 857                 break;
 858         case BLOWFISH_ECB_MECH_INFO_TYPE:
 859                 blowfish_ctx->bc_flags |= ECB_MODE;
 860         }
 861
 862         if (rv != CRYPTO_SUCCESS) {
 863                 if (blowfish_ctx->bc_flags & PROVIDER_OWNS_KEY_SCHEDULE) {
 864                         bzero(keysched, size);
 865                         kmem_free(keysched, size);
 866                 }
 867         }
 868
 869         return (rv);
 870 }