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 #ifndef _KERNEL
27 #include <stdlib.h>
28 #endif
29
30 #include <sys/strsun.h>
31 #include <sys/types.h>
32 #include <modes/modes.h>
33 #include <sys/crypto/common.h>
34 #include <sys/crypto/impl.h>
35
36 /*
37 * Initialize by setting iov_or_mp to point to the current iovec or mp,
38 * and by setting current_offset to an offset within the current iovec or mp.
39 */
40 void
41 crypto_init_ptrs(crypto_data_t *out, void **iov_or_mp, offset_t *current_offset)
42 {
43 offset_t offset;
44
45 switch (out->cd_format) {
46 case CRYPTO_DATA_RAW:
47 *current_offset = out->cd_offset;
48 break;
49
50 case CRYPTO_DATA_UIO: {
51 uio_t *uiop = out->cd_uio;
52 uintptr_t vec_idx;
53
54 offset = out->cd_offset;
55 for (vec_idx = 0; vec_idx < uiop->uio_iovcnt &&
56 offset >= uiop->uio_iov[vec_idx].iov_len;
57 offset -= uiop->uio_iov[vec_idx++].iov_len)
58 ;
59
60 *current_offset = offset;
61 *iov_or_mp = (void *)vec_idx;
62 break;
63 }
64
65 case CRYPTO_DATA_MBLK: {
66 mblk_t *mp;
67
68 offset = out->cd_offset;
69 for (mp = out->cd_mp; mp != NULL && offset >= MBLKL(mp);
70 offset -= MBLKL(mp), mp = mp->b_cont)
71 ;
72
73 *current_offset = offset;
74 *iov_or_mp = mp;
75 break;
76
77 }
78 } /* end switch */
79 }
80
81 /*
82 * Get pointers for where in the output to copy a block of encrypted or
83 * decrypted data. The iov_or_mp argument stores a pointer to the current
84 * iovec or mp, and offset stores an offset into the current iovec or mp.
85 */
86 void
87 crypto_get_ptrs(crypto_data_t *out, void **iov_or_mp, offset_t *current_offset,
88 uint8_t **out_data_1, size_t *out_data_1_len, uint8_t **out_data_2,
89 size_t amt)
90 {
91 offset_t offset;
92
93 switch (out->cd_format) {
94 case CRYPTO_DATA_RAW: {
95 iovec_t *iov;
96
97 offset = *current_offset;
98 iov = &out->cd_raw;
99 if ((offset + amt) <= iov->iov_len) {
100 /* one block fits */
101 *out_data_1 = (uint8_t *)iov->iov_base + offset;
102 *out_data_1_len = amt;
103 *out_data_2 = NULL;
104 *current_offset = offset + amt;
105 }
106 break;
107 }
108
109 case CRYPTO_DATA_UIO: {
110 uio_t *uio = out->cd_uio;
111 iovec_t *iov;
112 offset_t offset;
113 uintptr_t vec_idx;
114 uint8_t *p;
115
116 offset = *current_offset;
117 vec_idx = (uintptr_t)(*iov_or_mp);
118 iov = &uio->uio_iov[vec_idx];
119 p = (uint8_t *)iov->iov_base + offset;
120 *out_data_1 = p;
121
122 if (offset + amt <= iov->iov_len) {
123 /* can fit one block into this iov */
124 *out_data_1_len = amt;
125 *out_data_2 = NULL;
126 *current_offset = offset + amt;
127 } else {
128 /* one block spans two iovecs */
129 *out_data_1_len = iov->iov_len - offset;
130 if (vec_idx == uio->uio_iovcnt)
131 return;
132 vec_idx++;
133 iov = &uio->uio_iov[vec_idx];
134 *out_data_2 = (uint8_t *)iov->iov_base;
135 *current_offset = amt - *out_data_1_len;
136 }
137 *iov_or_mp = (void *)vec_idx;
138 break;
139 }
140
141 case CRYPTO_DATA_MBLK: {
142 mblk_t *mp;
143 uint8_t *p;
144
145 offset = *current_offset;
146 mp = (mblk_t *)*iov_or_mp;
147 p = mp->b_rptr + offset;
148 *out_data_1 = p;
149 if ((p + amt) <= mp->b_wptr) {
150 /* can fit one block into this mblk */
151 *out_data_1_len = amt;
152 *out_data_2 = NULL;
153 *current_offset = offset + amt;
154 } else {
155 /* one block spans two mblks */
156 *out_data_1_len = _PTRDIFF(mp->b_wptr, p);
157 if ((mp = mp->b_cont) == NULL)
158 return;
159 *out_data_2 = mp->b_rptr;
160 *current_offset = (amt - *out_data_1_len);
161 }
162 *iov_or_mp = mp;
163 break;
164 }
165 } /* end switch */
166 }
167
168 void
169 crypto_free_mode_ctx(void *ctx)
170 {
171 common_ctx_t *common_ctx = (common_ctx_t *)ctx;
172
173 switch (common_ctx->cc_flags &
174 (ECB_MODE|CBC_MODE|CTR_MODE|CCM_MODE|GCM_MODE|GMAC_MODE)) {
175 case ECB_MODE:
176 #ifdef _KERNEL
177 kmem_free(common_ctx, sizeof (ecb_ctx_t));
178 #else
179 free(common_ctx);
180 #endif
181 break;
182
183 case CBC_MODE:
184 #ifdef _KERNEL
185 kmem_free(common_ctx, sizeof (cbc_ctx_t));
186 #else
187 free(common_ctx);
188 #endif
189 break;
190
191 case CTR_MODE:
192 #ifdef _KERNEL
193 kmem_free(common_ctx, sizeof (ctr_ctx_t));
194 #else
195 free(common_ctx);
196 #endif
197 break;
198
199 case CCM_MODE:
200 #ifdef _KERNEL
201 if (((ccm_ctx_t *)ctx)->ccm_pt_buf != NULL)
202 kmem_free(((ccm_ctx_t *)ctx)->ccm_pt_buf,
203 ((ccm_ctx_t *)ctx)->ccm_data_len);
204
205 kmem_free(ctx, sizeof (ccm_ctx_t));
206 #else
207 if (((ccm_ctx_t *)ctx)->ccm_pt_buf != NULL)
208 free(((ccm_ctx_t *)ctx)->ccm_pt_buf);
209 free(ctx);
210 #endif
211 break;
212
213 case GCM_MODE:
214 case GMAC_MODE:
215 #ifdef _KERNEL
216 if (((gcm_ctx_t *)ctx)->gcm_pt_buf != NULL)
217 kmem_free(((gcm_ctx_t *)ctx)->gcm_pt_buf,
218 ((gcm_ctx_t *)ctx)->gcm_pt_buf_len);
219
220 kmem_free(ctx, sizeof (gcm_ctx_t));
221 #else
222 if (((gcm_ctx_t *)ctx)->gcm_pt_buf != NULL)
223 free(((gcm_ctx_t *)ctx)->gcm_pt_buf);
224 free(ctx);
225 #endif
226 }
227 }