usr/src/common/crypto/modes/modes.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 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  *
  25  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
  26  */
  27
  28 #ifndef _KERNEL
  29 #include <stdlib.h>
  30 #include <assert.h>
  31 #include <strings.h>
  32 #endif
  33
  34 #include <sys/strsun.h>
  35 #include <sys/types.h>
  36 #include <modes/modes.h>
  37 #include <sys/crypto/common.h>
  38 #include <sys/crypto/impl.h>
  39
  40 /*
  41  * Initialize by setting iov_or_mp to point to the current iovec or mp,
  42  * and by setting current_offset to an offset within the current iovec or mp.
  43  */
  44 void
  45 crypto_init_ptrs(crypto_data_t *out, void **iov_or_mp, offset_t *current_offset)
  46 {
  47         offset_t offset;
  48
  49         switch (out->cd_format) {
  50         case CRYPTO_DATA_RAW:
  51                 *current_offset = out->cd_offset;
  52                 break;
  53
  54         case CRYPTO_DATA_UIO: {
  55                 uio_t *uiop = out->cd_uio;
  56                 uintptr_t vec_idx;
  57
  58                 offset = out->cd_offset;
  59                 for (vec_idx = 0; vec_idx < uiop->uio_iovcnt &&
  60                     offset >= uiop->uio_iov[vec_idx].iov_len;
  61                     offset -= uiop->uio_iov[vec_idx++].iov_len)
  62                         ;
  63
  64                 *current_offset = offset;
  65                 *iov_or_mp = (void *)vec_idx;
  66                 break;
  67         }
  68
  69         case CRYPTO_DATA_MBLK: {
  70                 mblk_t *mp;
  71
  72                 offset = out->cd_offset;
  73                 for (mp = out->cd_mp; mp != NULL && offset >= MBLKL(mp);
  74                     offset -= MBLKL(mp), mp = mp->b_cont)
  75                         ;
  76
  77                 *current_offset = offset;
  78                 *iov_or_mp = mp;
  79                 break;
  80
  81         }
  82         } /* end switch */
  83 }
  84
  85 /*
  86  * Get pointers for where in the output to copy a block of encrypted or
  87  * decrypted data.  The iov_or_mp argument stores a pointer to the current
  88  * iovec or mp, and offset stores an offset into the current iovec or mp.
  89  */
  90 void
  91 crypto_get_ptrs(crypto_data_t *out, void **iov_or_mp, offset_t *current_offset,
  92     uint8_t **out_data_1, size_t *out_data_1_len, uint8_t **out_data_2,
  93     size_t amt)
  94 {
  95         offset_t offset;
  96
  97         switch (out->cd_format) {
  98         case CRYPTO_DATA_RAW: {
  99                 iovec_t *iov;
 100
 101                 offset = *current_offset;
 102                 iov = &out->cd_raw;
 103                 if ((offset + amt) <= iov->iov_len) {
 104                         /* one block fits */
 105                         *out_data_1 = (uint8_t *)iov->iov_base + offset;
 106                         *out_data_1_len = amt;
 107                         *out_data_2 = NULL;
 108                         *current_offset = offset + amt;
 109                 }
 110                 break;
 111         }
 112
 113         case CRYPTO_DATA_UIO: {
 114                 uio_t *uio = out->cd_uio;
 115                 iovec_t *iov;
 116                 offset_t offset;
 117                 uintptr_t vec_idx;
 118                 uint8_t *p;
 119
 120                 offset = *current_offset;
 121                 vec_idx = (uintptr_t)(*iov_or_mp);
 122                 iov = &uio->uio_iov[vec_idx];
 123                 p = (uint8_t *)iov->iov_base + offset;
 124                 *out_data_1 = p;
 125
 126                 if (offset + amt <= iov->iov_len) {
 127                         /* can fit one block into this iov */
 128                         *out_data_1_len = amt;
 129                         *out_data_2 = NULL;
 130                         *current_offset = offset + amt;
 131                 } else {
 132                         /* one block spans two iovecs */
 133                         *out_data_1_len = iov->iov_len - offset;
 134                         if (vec_idx == uio->uio_iovcnt)
 135                                 return;
 136                         vec_idx++;
 137                         iov = &uio->uio_iov[vec_idx];
 138                         *out_data_2 = (uint8_t *)iov->iov_base;
 139                         *current_offset = amt - *out_data_1_len;
 140                 }
 141                 *iov_or_mp = (void *)vec_idx;
 142                 break;
 143         }
 144
 145         case CRYPTO_DATA_MBLK: {
 146                 mblk_t *mp;
 147                 uint8_t *p;
 148
 149                 offset = *current_offset;
 150                 mp = (mblk_t *)*iov_or_mp;
 151                 p = mp->b_rptr + offset;
 152                 *out_data_1 = p;
 153                 if ((p + amt) <= mp->b_wptr) {
 154                         /* can fit one block into this mblk */
 155                         *out_data_1_len = amt;
 156                         *out_data_2 = NULL;
 157                         *current_offset = offset + amt;
 158                 } else {
 159                         /* one block spans two mblks */
 160                         *out_data_1_len = _PTRDIFF(mp->b_wptr, p);
 161                         if ((mp = mp->b_cont) == NULL)
 162                                 return;
 163                         *out_data_2 = mp->b_rptr;
 164                         *current_offset = (amt - *out_data_1_len);
 165                 }
 166                 *iov_or_mp = mp;
 167                 break;
 168         }
 169         } /* end switch */
 170 }
 171
 172 void
 173 crypto_free_mode_ctx(void *ctx)
 174 {
 175         common_ctx_t *common_ctx = (common_ctx_t *)ctx;
 176
 177         switch (common_ctx->cc_flags & (ECB_MODE|CBC_MODE|CMAC_MODE|CTR_MODE|
 178             CCM_MODE|GCM_MODE|GMAC_MODE)) {
 179         case ECB_MODE:
 180 #ifdef _KERNEL
 181                 kmem_free(common_ctx, sizeof (ecb_ctx_t));
 182 #else
 183                 free(common_ctx);
 184 #endif
 185                 break;
 186
 187         case CBC_MODE:
 188         case CMAC_MODE:
 189 #ifdef _KERNEL
 190                 kmem_free(common_ctx, sizeof (cbc_ctx_t));
 191 #else
 192                 free(common_ctx);
 193 #endif
 194                 break;
 195
 196         case CTR_MODE:
 197 #ifdef _KERNEL
 198                 kmem_free(common_ctx, sizeof (ctr_ctx_t));
 199 #else
 200                 free(common_ctx);
 201 #endif
 202                 break;
 203
 204         case CCM_MODE:
 205 #ifdef _KERNEL
 206                 if (((ccm_ctx_t *)ctx)->ccm_pt_buf != NULL)
 207                         kmem_free(((ccm_ctx_t *)ctx)->ccm_pt_buf,
 208                             ((ccm_ctx_t *)ctx)->ccm_data_len);
 209
 210                 kmem_free(ctx, sizeof (ccm_ctx_t));
 211 #else
 212                 if (((ccm_ctx_t *)ctx)->ccm_pt_buf != NULL)
 213                         free(((ccm_ctx_t *)ctx)->ccm_pt_buf);
 214                 free(ctx);
 215 #endif
 216                 break;
 217
 218         case GCM_MODE:
 219         case GMAC_MODE:
 220 #ifdef _KERNEL
 221                 if (((gcm_ctx_t *)ctx)->gcm_pt_buf != NULL)
 222                         kmem_free(((gcm_ctx_t *)ctx)->gcm_pt_buf,
 223                             ((gcm_ctx_t *)ctx)->gcm_pt_buf_len);
 224
 225                 kmem_free(ctx, sizeof (gcm_ctx_t));
 226 #else
 227                 if (((gcm_ctx_t *)ctx)->gcm_pt_buf != NULL)
 228                         free(((gcm_ctx_t *)ctx)->gcm_pt_buf);
 229                 free(ctx);
 230 #endif
 231         }
 232 }
 233
 234 /*
 235  * Utility routine to apply the command, 'cmd', to the
 236  * data in the uio structure.
 237  */
 238 int
 239 crypto_uio_data(crypto_data_t *data, uchar_t *buf, int len, cmd_type_t cmd,
 240     void *digest_ctx, void (*update)())
 241 {
 242         uio_t *uiop = data->cd_uio;
 243         off_t offset = data->cd_offset;
 244         size_t length = len;
 245         uint_t vec_idx;
 246         size_t cur_len;
 247         uchar_t *datap;
 248
 249 #ifdef _KERNEL
 250         ASSERT3U(data->cd_format, ==, CRYPTO_DATA_UIO);
 251 #else
 252         assert(data->cd_format == CRYPTO_DATA_UIO);
 253 #endif
 254         if (uiop->uio_segflg != UIO_SYSSPACE) {
 255                 return (CRYPTO_ARGUMENTS_BAD);
 256         }
 257
 258         /*
 259          * Jump to the first iovec containing data to be
 260          * processed.
 261          */
 262         for (vec_idx = 0; vec_idx < uiop->uio_iovcnt &&
 263             offset >= uiop->uio_iov[vec_idx].iov_len;
 264             offset -= uiop->uio_iov[vec_idx++].iov_len)
 265                 ;
 266
 267         if (vec_idx == uiop->uio_iovcnt) {
 268                 /*
 269                  * The caller specified an offset that is larger than
 270                  * the total size of the buffers it provided.
 271                  */
 272                 return (CRYPTO_DATA_LEN_RANGE);
 273         }
 274
 275         while (vec_idx < uiop->uio_iovcnt && length > 0) {
 276                 cur_len = MIN(uiop->uio_iov[vec_idx].iov_len -
 277                     offset, length);
 278
 279                 datap = (uchar_t *)(uiop->uio_iov[vec_idx].iov_base +
 280                     offset);
 281                 switch (cmd) {
 282                 case COPY_FROM_DATA:
 283                         bcopy(datap, buf, cur_len);
 284                         buf += cur_len;
 285                         break;
 286                 case COPY_TO_DATA:
 287                         bcopy(buf, datap, cur_len);
 288                         buf += cur_len;
 289                         break;
 290                 case COMPARE_TO_DATA:
 291                         if (bcmp(datap, buf, cur_len))
 292                                 return (CRYPTO_SIGNATURE_INVALID);
 293                         buf += cur_len;
 294                         break;
 295                 case MD5_DIGEST_DATA:
 296                 case SHA1_DIGEST_DATA:
 297                 case SHA2_DIGEST_DATA:
 298                 case GHASH_DATA:
 299                         update(digest_ctx, datap, cur_len);
 300                         break;
 301                 }
 302
 303                 length -= cur_len;
 304                 vec_idx++;
 305                 offset = 0;
 306         }
 307
 308         if (vec_idx == uiop->uio_iovcnt && length > 0) {
 309                 /*
 310                  * The end of the specified iovec's was reached but
 311                  * the length requested could not be processed.
 312                  */
 313                 switch (cmd) {
 314                 case COPY_TO_DATA:
 315                         data->cd_length = len;
 316                         return (CRYPTO_BUFFER_TOO_SMALL);
 317                 default:
 318                         return (CRYPTO_DATA_LEN_RANGE);
 319                 }
 320         }
 321
 322         return (CRYPTO_SUCCESS);
 323 }
 324
 325 /*
 326  * Utility routine to apply the command, 'cmd', to the
 327  * data in the mblk structure.
 328  */
 329 int
 330 crypto_mblk_data(crypto_data_t *data, uchar_t *buf, int len, cmd_type_t cmd,
 331     void *digest_ctx, void (*update)())
 332 {
 333         off_t offset = data->cd_offset;
 334         size_t length = len;
 335         mblk_t *mp;
 336         size_t cur_len;
 337         uchar_t *datap;
 338
 339 #ifdef _KERNEL
 340         ASSERT3U(data->cd_format, ==, CRYPTO_DATA_MBLK);
 341 #else
 342         assert(data->cd_format == CRYPTO_DATA_MBLK);
 343 #endif
 344         /*
 345          * Jump to the first mblk_t containing data to be processed.
 346          */
 347         for (mp = data->cd_mp; mp != NULL && offset >= MBLKL(mp);
 348             offset -= MBLKL(mp), mp = mp->b_cont)
 349                 ;
 350         if (mp == NULL) {
 351                 /*
 352                  * The caller specified an offset that is larger
 353                  * than the total size of the buffers it provided.
 354                  */
 355                 return (CRYPTO_DATA_LEN_RANGE);
 356         }
 357
 358         /*
 359          * Now do the processing on the mblk chain.
 360          */
 361         while (mp != NULL && length > 0) {
 362                 cur_len = MIN(MBLKL(mp) - offset, length);
 363
 364                 datap = (uchar_t *)(mp->b_rptr + offset);
 365                 switch (cmd) {
 366                 case COPY_FROM_DATA:
 367                         bcopy(datap, buf, cur_len);
 368                         buf += cur_len;
 369                         break;
 370                 case COPY_TO_DATA:
 371                         bcopy(buf, datap, cur_len);
 372                         buf += cur_len;
 373                         break;
 374                 case COMPARE_TO_DATA:
 375                         if (bcmp(datap, buf, cur_len))
 376                                 return (CRYPTO_SIGNATURE_INVALID);
 377                         buf += cur_len;
 378                         break;
 379                 case MD5_DIGEST_DATA:
 380                 case SHA1_DIGEST_DATA:
 381                 case SHA2_DIGEST_DATA:
 382                 case GHASH_DATA:
 383                         update(digest_ctx, datap, cur_len);
 384                         break;
 385                 }
 386
 387                 length -= cur_len;
 388                 offset = 0;
 389                 mp = mp->b_cont;
 390         }
 391
 392         if (mp == NULL && length > 0) {
 393                 /*
 394                  * The end of the mblk was reached but the length
 395                  * requested could not be processed.
 396                  */
 397                 switch (cmd) {
 398                 case COPY_TO_DATA:
 399                         data->cd_length = len;
 400                         return (CRYPTO_BUFFER_TOO_SMALL);
 401                 default:
 402                         return (CRYPTO_DATA_LEN_RANGE);
 403                 }
 404         }
 405
 406         return (CRYPTO_SUCCESS);
 407 }
 408
 409 /*
 410  * Utility routine to copy a buffer to a crypto_data structure.
 411  */
 412 int
 413 crypto_put_output_data(uchar_t *buf, crypto_data_t *output, int len)
 414 {
 415         switch (output->cd_format) {
 416         case CRYPTO_DATA_RAW:
 417                 if (MAXOFF_T - output->cd_offset < (off_t)len) {
 418                         return (CRYPTO_ARGUMENTS_BAD);
 419                 }
 420                 if (output->cd_raw.iov_len < len + output->cd_offset) {
 421                         output->cd_length = len;
 422                         return (CRYPTO_BUFFER_TOO_SMALL);
 423                 }
 424                 bcopy(buf, (uchar_t *)(output->cd_raw.iov_base +
 425                     output->cd_offset), len);
 426                 break;
 427
 428         case CRYPTO_DATA_UIO:
 429                 return (crypto_uio_data(output, buf, len,
 430                     COPY_TO_DATA, NULL, NULL));
 431
 432         case CRYPTO_DATA_MBLK:
 433                 return (crypto_mblk_data(output, buf, len,
 434                     COPY_TO_DATA, NULL, NULL));
 435
 436         default:
 437                 return (CRYPTO_ARGUMENTS_BAD);
 438         }
 439
 440         return (CRYPTO_SUCCESS);
 441 }