module/icp/algs/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
  26 #include <sys/zfs_context.h>
  27 #include <modes/modes.h>
  28 #include <sys/crypto/common.h>
  29 #include <sys/crypto/impl.h>
  30
  31 /*
  32  * Initialize by setting iov_or_mp to point to the current iovec or mp,
  33  * and by setting current_offset to an offset within the current iovec or mp.
  34  */
  35 void
  36 crypto_init_ptrs(crypto_data_t *out, void **iov_or_mp, offset_t *current_offset)
  37 {
  38         offset_t offset;
  39
  40         switch (out->cd_format) {
  41         case CRYPTO_DATA_RAW:
  42                 *current_offset = out->cd_offset;
  43                 break;
  44
  45         case CRYPTO_DATA_UIO: {
  46                 uio_t *uiop = out->cd_uio;
  47                 uint_t vec_idx;
  48
  49                 offset = out->cd_offset;
  50                 offset = uio_index_at_offset(uiop, offset, &vec_idx);
  51
  52                 *current_offset = offset;
  53                 *iov_or_mp = (void *)(uintptr_t)vec_idx;
  54                 break;
  55         }
  56         } /* end switch */
  57 }
  58
  59 /*
  60  * Get pointers for where in the output to copy a block of encrypted or
  61  * decrypted data.  The iov_or_mp argument stores a pointer to the current
  62  * iovec or mp, and offset stores an offset into the current iovec or mp.
  63  */
  64 void
  65 crypto_get_ptrs(crypto_data_t *out, void **iov_or_mp, offset_t *current_offset,
  66     uint8_t **out_data_1, size_t *out_data_1_len, uint8_t **out_data_2,
  67     size_t amt)
  68 {
  69         offset_t offset;
  70
  71         switch (out->cd_format) {
  72         case CRYPTO_DATA_RAW: {
  73                 iovec_t *iov;
  74
  75                 offset = *current_offset;
  76                 iov = &out->cd_raw;
  77                 if ((offset + amt) <= iov->iov_len) {
  78                         /* one block fits */
  79                         *out_data_1 = (uint8_t *)iov->iov_base + offset;
  80                         *out_data_1_len = amt;
  81                         *out_data_2 = NULL;
  82                         *current_offset = offset + amt;
  83                 }
  84                 break;
  85         }
  86
  87         case CRYPTO_DATA_UIO: {
  88                 uio_t *uio = out->cd_uio;
  89                 offset_t offset;
  90                 uint_t vec_idx;
  91                 uint8_t *p;
  92                 uint64_t iov_len;
  93                 void *iov_base;
  94
  95                 offset = *current_offset;
  96                 vec_idx = (uintptr_t)(*iov_or_mp);
  97                 uio_iov_at_index(uio, vec_idx, &iov_base, &iov_len);
  98                 p = (uint8_t *)iov_base + offset;
  99                 *out_data_1 = p;
 100
 101                 if (offset + amt <= iov_len) {
 102                         /* can fit one block into this iov */
 103                         *out_data_1_len = amt;
 104                         *out_data_2 = NULL;
 105                         *current_offset = offset + amt;
 106                 } else {
 107                         /* one block spans two iovecs */
 108                         *out_data_1_len = iov_len - offset;
 109                         if (vec_idx == uio_iovcnt(uio))
 110                                 return;
 111                         vec_idx++;
 112                         uio_iov_at_index(uio, vec_idx, &iov_base, &iov_len);
 113                         *out_data_2 = (uint8_t *)iov_base;
 114                         *current_offset = amt - *out_data_1_len;
 115                 }
 116                 *iov_or_mp = (void *)(uintptr_t)vec_idx;
 117                 break;
 118         }
 119         } /* end switch */
 120 }
 121
 122 void
 123 crypto_free_mode_ctx(void *ctx)
 124 {
 125         common_ctx_t *common_ctx = (common_ctx_t *)ctx;
 126
 127         switch (common_ctx->cc_flags &
 128             (ECB_MODE|CBC_MODE|CTR_MODE|CCM_MODE|GCM_MODE|GMAC_MODE)) {
 129         case ECB_MODE:
 130                 kmem_free(common_ctx, sizeof (ecb_ctx_t));
 131                 break;
 132
 133         case CBC_MODE:
 134                 kmem_free(common_ctx, sizeof (cbc_ctx_t));
 135                 break;
 136
 137         case CTR_MODE:
 138                 kmem_free(common_ctx, sizeof (ctr_ctx_t));
 139                 break;
 140
 141         case CCM_MODE:
 142                 if (((ccm_ctx_t *)ctx)->ccm_pt_buf != NULL)
 143                         vmem_free(((ccm_ctx_t *)ctx)->ccm_pt_buf,
 144                             ((ccm_ctx_t *)ctx)->ccm_data_len);
 145
 146                 kmem_free(ctx, sizeof (ccm_ctx_t));
 147                 break;
 148
 149         case GCM_MODE:
 150         case GMAC_MODE:
 151                 if (((gcm_ctx_t *)ctx)->gcm_pt_buf != NULL)
 152                         vmem_free(((gcm_ctx_t *)ctx)->gcm_pt_buf,
 153                             ((gcm_ctx_t *)ctx)->gcm_pt_buf_len);
 154
 155                 kmem_free(ctx, sizeof (gcm_ctx_t));
 156         }
 157 }