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 /*
28 * Dummy Cryptographic Provider:
29 *
30 * This file implements a "dummy" cryptographic provider. It is implemented
31 * as a pseudo device driver.
32 *
33 */
34
35 /*
36 * This driver implements a KEF provider with the following capabilities:
37 *
38 * - registration/unregistration with KEF
39 * - digest entry points
40 * - mac entry points
41 * - ctx management
42 * - support for async requests
43 * - cipher entry points
44 * - dual entry points
45 * - sign entry points
46 * - verify entry points
47 * - dual operations entry points
48 * - dual cipher/mac operation entry points
49 * - session management
50 * - object management
51 * - key management
52 * - provider management
53 *
54 * In order to avoid duplicating the implementation of algorithms
55 * provided by software providers, this pseudo driver acts as
56 * a consumer of the framework. When invoking one of the framework's
57 * entry points, the driver specifies the software provider to
58 * be used for the operation.
59 *
60 * User management: we implement a PKCS#11 style provider which supports:
61 * - one normal user with a PIN, and
62 * - one SO user with a PIN.
63 * These values are kept in the per-instance structure, and are initialized
64 * with the provider management entry points.
65 *
66 */
67
68
69 #include <sys/types.h>
70 #include <sys/modctl.h>
71 #include <sys/conf.h>
72 #include <sys/stat.h>
73 #include <sys/ddi.h>
74 #include <sys/sunddi.h>
75 #include <sys/kmem.h>
76 #include <sys/errno.h>
77 #include <sys/ksynch.h>
78 #include <sys/file.h>
79 #include <sys/open.h>
80 #include <sys/cred.h>
81 #include <sys/model.h>
82 #include <sys/note.h>
83 #include <sys/random.h>
84 #include <sys/byteorder.h>
85 #include <sys/crypto/common.h>
86 #include <sys/crypto/spi.h>
87
88 #include <sys/taskq.h>
89 #include <sys/disp.h>
90 #include <sys/sysmacros.h>
91 #include <sys/crypto/impl.h>
92 #include <sys/crypto/sched_impl.h>
93
94 #include <sys/sha2.h>
95 #include <modes/modes.h>
96 #include <aes/aes_impl.h>
97 #include <des/des_impl.h>
98 #include <ecc/ecc_impl.h>
99 #include <blowfish/blowfish_impl.h>
100
101 /*
102 * Debugging macros.
103 */
104 #ifdef DEBUG
105 #define D_INIT 0x00000001 /* _init/_fini/_info */
106 #define D_ATTACH 0x00000002 /* attach/detach */
107 #define D_DIGEST 0x00000010 /* digest entry points */
108 #define D_MAC 0x00000020 /* mac entry points */
109 #define D_CONTEXT 0x00000040 /* context entry points */
110 #define D_CIPHER 0x00000080 /* cipher entry points */
111 #define D_SIGN 0x00000100 /* sign entry points */
112 #define D_VERIFY 0x00000200 /* verify entry points */
113 #define D_SESSION 0x00000400 /* session management entry points */
114 #define D_MGMT 0x00000800 /* provider management entry points */
115 #define D_DUAL 0x00001000 /* dual ops */
116 #define D_CIPHER_MAC 0x00002000 /* cipher/mac dual ops */
117 #define D_OBJECT 0x00004000 /* object management */
118 #define D_RANDOM 0x00008000 /* random number generation */
119 #define D_KEY 0x00010000 /* key management */
120
121 static uint32_t dprov_debug = 0;
122
123 #define DPROV_DEBUG(f, x) if (dprov_debug & (f)) { (void) printf x; }
124 #define DPROV_CALL(f, r, x) if (dprov_debug & (f)) { (void) r x; }
125 #else /* DEBUG */
126 #define DPROV_DEBUG(f, x)
127 #define DPROV_CALL(f, r, x)
128 #endif /* DEBUG */
129
130 static int nostore_key_gen;
131 static boolean_t dprov_no_multipart = B_FALSE;
132 static int dprov_max_digestsz = INT_MAX;
133
134 /*
135 * DDI entry points.
136 */
137 static int dprov_attach(dev_info_t *, ddi_attach_cmd_t);
138 static int dprov_detach(dev_info_t *, ddi_detach_cmd_t);
139 static int dprov_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
140
141 /*
142 * Module linkage.
143 */
144 static struct cb_ops cbops = {
145 nodev, /* cb_open */
146 nodev, /* cb_close */
147 nodev, /* cb_strategy */
148 nodev, /* cb_print */
149 nodev, /* cb_dump */
150 nodev, /* cb_read */
151 nodev, /* cb_write */
152 nodev, /* cb_ioctl */
153 nodev, /* cb_devmap */
154 nodev, /* cb_mmap */
155 nodev, /* cb_segmap */
156 nochpoll, /* cb_chpoll */
157 ddi_prop_op, /* cb_prop_op */
158 NULL, /* cb_streamtab */
159 D_MP, /* cb_flag */
160 CB_REV, /* cb_rev */
161 nodev, /* cb_aread */
162 nodev, /* cb_awrite */
163 };
164
165 static struct dev_ops devops = {
166 DEVO_REV, /* devo_rev */
167 0, /* devo_refcnt */
168 dprov_getinfo, /* devo_getinfo */
169 nulldev, /* devo_identify */
170 nulldev, /* devo_probe */
171 dprov_attach, /* devo_attach */
172 dprov_detach, /* devo_detach */
173 nodev, /* devo_reset */
174 &cbops, /* devo_cb_ops */
175 NULL, /* devo_bus_ops */
176 NULL, /* devo_power */
177 ddi_quiesce_not_needed, /* devo_quiesce */
178 };
179
180 static struct modldrv modldrv = {
181 &mod_driverops,
182 "Pseudo KCF Prov (drv)",
183 &devops
184 };
185
186 static struct modlcrypto modlcrypto = {
187 &mod_cryptoops,
188 "Pseudo KCF Prov (crypto)"
189 };
190
191 static struct modlinkage modlinkage = {
192 MODREV_1,
193 &modldrv,
194 &modlcrypto,
195 NULL
196 };
197
198 /*
199 * CSPI information (entry points, provider info, etc.)
200 */
201
202 typedef enum dprov_mech_type {
203 MD4_MECH_INFO_TYPE, /* SUN_CKM_MD4 */
204
205 MD5_MECH_INFO_TYPE, /* SUN_CKM_MD5 */
206 MD5_HMAC_MECH_INFO_TYPE, /* SUN_CKM_MD5_HMAC */
207 MD5_HMAC_GEN_MECH_INFO_TYPE, /* SUN_CKM_MD5_HMAC_GENERAL */
208
209 SHA1_HMAC_MECH_INFO_TYPE, /* SUN_CKM_SHA1_HMAC */
210 SHA1_HMAC_GEN_MECH_INFO_TYPE, /* SUN_CKM_SHA1_HMAC_GENERAL */
211 SHA1_MECH_INFO_TYPE, /* SUN_CKM_SHA1 */
212
213 SHA256_HMAC_MECH_INFO_TYPE, /* SUN_CKM_SHA256_HMAC */
214 SHA256_HMAC_GEN_MECH_INFO_TYPE, /* SUN_CKM_SHA256_HMAC_GENERAL */
215 SHA256_MECH_INFO_TYPE, /* SUN_CKM_SHA256 */
216 SHA384_HMAC_MECH_INFO_TYPE, /* SUN_CKM_SHA384_HMAC */
217 SHA384_HMAC_GEN_MECH_INFO_TYPE, /* SUN_CKM_SHA384_HMAC_GENERAL */
218 SHA384_MECH_INFO_TYPE, /* SUN_CKM_SHA384 */
219 SHA512_HMAC_MECH_INFO_TYPE, /* SUN_CKM_SHA512_HMAC */
220 SHA512_HMAC_GEN_MECH_INFO_TYPE, /* SUN_CKM_SHA512_HMAC_GENERAL */
221 SHA512_MECH_INFO_TYPE, /* SUN_CKM_SHA512 */
222
223 DES_CBC_MECH_INFO_TYPE, /* SUN_CKM_DES_CBC */
224 DES3_CBC_MECH_INFO_TYPE, /* SUN_CKM_DES3_CBC */
225 DES_ECB_MECH_INFO_TYPE, /* SUN_CKM_DES_ECB */
226 DES3_ECB_MECH_INFO_TYPE, /* SUN_CKM_DES3_ECB */
227
228 BLOWFISH_CBC_MECH_INFO_TYPE, /* SUN_CKM_BLOWFISH_CBC */
229 BLOWFISH_ECB_MECH_INFO_TYPE, /* SUN_CKM_BLOWFISH_ECB */
230 AES_CBC_MECH_INFO_TYPE, /* SUN_CKM_AES_CBC */
231 AES_ECB_MECH_INFO_TYPE, /* SUN_CKM_AES_ECB */
232 AES_CTR_MECH_INFO_TYPE, /* SUN_CKM_AES_CTR */
233 AES_CCM_MECH_INFO_TYPE, /* SUN_CKM_AES_CCM */
234 AES_GCM_MECH_INFO_TYPE, /* SUN_CKM_AES_GCM */
235 AES_GMAC_MECH_INFO_TYPE, /* SUN_CKM_AES_GMAC */
236 RC4_MECH_INFO_TYPE, /* SUN_CKM_RC4 */
237 RSA_PKCS_MECH_INFO_TYPE, /* SUN_CKM_RSA_PKCS */
238 RSA_X_509_MECH_INFO_TYPE, /* SUN_CKM_RSA_X_509 */
239 MD5_RSA_PKCS_MECH_INFO_TYPE, /* SUN_CKM_MD5_RSA_PKCS */
240 SHA1_RSA_PKCS_MECH_INFO_TYPE, /* SUN_CKM_SHA1_RSA_PKCS */
241 SHA256_RSA_PKCS_MECH_INFO_TYPE, /* SUN_CKM_SHA256_RSA_PKCS */
242 SHA384_RSA_PKCS_MECH_INFO_TYPE, /* SUN_CKM_SHA384_RSA_PKCS */
243 SHA512_RSA_PKCS_MECH_INFO_TYPE, /* SUN_CKM_SHA512_RSA_PKCS */
244 MD5_KEY_DERIVATION_MECH_INFO_TYPE, /* SUN_CKM_MD5_KEY_DERIVATION */
245 SHA1_KEY_DERIVATION_MECH_INFO_TYPE, /* SUN_CKM_SHA1_KEY_DERIVATION */
246 /* SUN_CKM_SHA256_KEY_DERIVATION */
247 SHA256_KEY_DERIVATION_MECH_INFO_TYPE,
248 /* SUN_CKM_SHA384_KEY_DERIVATION */
249 SHA384_KEY_DERIVATION_MECH_INFO_TYPE,
250 /* SUN_CKM_SHA512_KEY_DERIVATION */
251 SHA512_KEY_DERIVATION_MECH_INFO_TYPE,
252 DES_KEY_GEN_MECH_INFO_TYPE, /* SUN_CKM_DES_KEY_GEN */
253 DES3_KEY_GEN_MECH_INFO_TYPE, /* SUN_CKM_DES3_KEY_GEN */
254 AES_KEY_GEN_MECH_INFO_TYPE, /* SUN_CKM_AES_KEY_GEN */
255 BLOWFISH_KEY_GEN_MECH_INFO_TYPE, /* SUN_CKM_BLOWFISH_KEY_GEN */
256 RC4_KEY_GEN_MECH_INFO_TYPE, /* SUN_CKM_RC4_KEY_GEN */
257 EC_KEY_PAIR_GEN_MECH_INFO_TYPE, /* SUN_CKM_EC_KEY_PAIR_GEN */
258 ECDSA_MECH_INFO_TYPE, /* SUN_CKM_ECDSA */
259 ECDSA_SHA1_MECH_INFO_TYPE, /* SUN_CKM_ECDSA_SHA1 */
260 ECDH1_DERIVE_MECH_INFO_TYPE, /* SUN_CKM_ECDH1_DERIVE */
261 DH_PKCS_KEY_PAIR_GEN_MECH_INFO_TYPE, /* SUN_CKM_DH_PKCS_KEY_PAIR_GEN */
262 DH_PKCS_DERIVE_MECH_INFO_TYPE, /* SUN_CKM_DH_PKCS_DERIVE */
263 RSA_PKCS_KEY_PAIR_GEN_MECH_INFO_TYPE /* SUN_CKM_RSA_PKCS_KEY_PAIR_GEN */
264 } dprov_mech_type_t;
265
266 /*
267 * Mechanism info structure passed to KCF during registration.
268 */
269 #define MD5_DIGEST_LEN 16 /* MD5 digest size */
270 #define MD5_HMAC_BLOCK_SIZE 64 /* MD5-HMAC block size */
271 #define MD5_HMAC_MIN_KEY_LEN 1 /* MD5-HMAC min key length in bytes */
272 #define MD5_HMAC_MAX_KEY_LEN INT_MAX /* MD5-HMAC max key length in bytes */
273
274 #define SHA1_DIGEST_LEN 20 /* SHA1 digest size */
275 #define SHA1_HMAC_BLOCK_SIZE 64 /* SHA1-HMAC block size */
276 #define SHA1_HMAC_MIN_KEY_LEN 1 /* SHA1-HMAC min key length in bytes */
277 #define SHA1_HMAC_MAX_KEY_LEN INT_MAX /* SHA1-HMAC max key length in bytes */
278
279 #define DES_KEY_LEN 8 /* DES key length in bytes */
280 #define DES3_KEY_LEN 24 /* DES3 key length in bytes */
281
282 #define BLOWFISH_MIN_KEY_LEN 32 /* Blowfish min key length in bits */
283 #define BLOWFISH_MAX_KEY_LEN 448 /* Blowfish max key length in bits */
284
285 #define AES_MIN_KEY_LEN 16 /* AES min key length in bytes */
286 #define AES_MAX_KEY_LEN 32 /* AES max key length in bytes */
287
288 #define ARCFOUR_MIN_KEY_BITS 40 /* RC4 min supported key size */
289 #define ARCFOUR_MAX_KEY_BITS 2048 /* RC4 max supported key size */
290
291 #define RSA_MIN_KEY_LEN 256 /* RSA min key length in bits */
292 #define RSA_MAX_KEY_LEN 4096 /* RSA max key length in bits */
293
294 #define DH_MIN_KEY_LEN 64 /* DH min key length in bits */
295 #define DH_MAX_KEY_LEN 4096 /* DH max key length in bits */
296
297 #define DPROV_CKM_MD5_KEY_DERIVATION "CKM_MD5_KEY_DERIVATION"
298 #define DPROV_CKM_SHA1_KEY_DERIVATION "CKM_SHA1_KEY_DERIVATION"
299 #define DPROV_CKM_SHA256_KEY_DERIVATION "CKM_SHA256_KEY_DERIVATION"
300 #define DPROV_CKM_SHA384_KEY_DERIVATION "CKM_SHA384_KEY_DERIVATION"
301 #define DPROV_CKM_SHA512_KEY_DERIVATION "CKM_SHA512_KEY_DERIVATION"
302 #define DPROV_CKM_DES_KEY_GEN "CKM_DES_KEY_GEN"
303 #define DPROV_CKM_DES3_KEY_GEN "CKM_DES3_KEY_GEN"
304 #define DPROV_CKM_AES_KEY_GEN "CKM_AES_KEY_GEN"
305 #define DPROV_CKM_BLOWFISH_KEY_GEN "CKM_BLOWFISH_KEY_GEN"
306 #define DPROV_CKM_RC4_KEY_GEN "CKM_RC4_KEY_GEN"
307 #define DPROV_CKM_RSA_PKCS_KEY_PAIR_GEN "CKM_RSA_PKCS_KEY_PAIR_GEN"
308 #define DPROV_CKM_EC_KEY_PAIR_GEN "CKM_EC_KEY_PAIR_GEN"
309 #define DPROV_CKM_ECDSA "CKM_ECDSA"
310 #define DPROV_CKM_ECDSA_SHA1 "CKM_ECDSA_SHA1"
311 #define DPROV_CKM_ECDH1_DERIVE "CKM_ECDH1_DERIVE"
312 #define DPROV_CKM_DH_PKCS_KEY_PAIR_GEN "CKM_DH_PKCS_KEY_PAIR_GEN"
313 #define DPROV_CKM_DH_PKCS_DERIVE "CKM_DH_PKCS_DERIVE"
314
315 static crypto_mech_info_t dprov_mech_info_tab[] = {
316 /* MD4 */
317 {SUN_CKM_MD4, MD4_MECH_INFO_TYPE,
318 CRYPTO_FG_DIGEST | CRYPTO_FG_DIGEST_ATOMIC, 0, 0,
319 CRYPTO_KEYSIZE_UNIT_IN_BITS},
320 /* MD5 */
321 {SUN_CKM_MD5, MD5_MECH_INFO_TYPE,
322 CRYPTO_FG_DIGEST | CRYPTO_FG_DIGEST_ATOMIC, 0, 0,
323 CRYPTO_KEYSIZE_UNIT_IN_BITS},
324 /* MD5-HMAC */
325 {SUN_CKM_MD5_HMAC, MD5_HMAC_MECH_INFO_TYPE,
326 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
327 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
328 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
329 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
330 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
331 MD5_HMAC_MIN_KEY_LEN, MD5_HMAC_MAX_KEY_LEN,
332 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
333 /* MD5-HMAC GENERAL */
334 {SUN_CKM_MD5_HMAC_GENERAL, MD5_HMAC_GEN_MECH_INFO_TYPE,
335 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
336 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
337 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
338 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
339 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
340 MD5_HMAC_MIN_KEY_LEN, MD5_HMAC_MAX_KEY_LEN,
341 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
342 /* SHA1 */
343 {SUN_CKM_SHA1, SHA1_MECH_INFO_TYPE,
344 CRYPTO_FG_DIGEST | CRYPTO_FG_DIGEST_ATOMIC, 0, 0,
345 CRYPTO_KEYSIZE_UNIT_IN_BITS},
346 /* SHA1-HMAC */
347 {SUN_CKM_SHA1_HMAC, SHA1_HMAC_MECH_INFO_TYPE,
348 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
349 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
350 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
351 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
352 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
353 SHA1_HMAC_MIN_KEY_LEN, SHA1_HMAC_MAX_KEY_LEN,
354 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
355 /* SHA1-HMAC GENERAL */
356 {SUN_CKM_SHA1_HMAC_GENERAL, SHA1_HMAC_GEN_MECH_INFO_TYPE,
357 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
358 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
359 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
360 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
361 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
362 SHA1_HMAC_MIN_KEY_LEN, SHA1_HMAC_MAX_KEY_LEN,
363 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
364 /* SHA256 */
365 {SUN_CKM_SHA256, SHA256_MECH_INFO_TYPE,
366 CRYPTO_FG_DIGEST | CRYPTO_FG_DIGEST_ATOMIC, 0, 0,
367 CRYPTO_KEYSIZE_UNIT_IN_BITS},
368 /* SHA256-HMAC */
369 {SUN_CKM_SHA256_HMAC, SHA256_HMAC_MECH_INFO_TYPE,
370 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
371 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
372 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
373 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
374 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
375 SHA2_HMAC_MIN_KEY_LEN, SHA2_HMAC_MAX_KEY_LEN,
376 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
377 /* SHA256-HMAC GENERAL */
378 {SUN_CKM_SHA256_HMAC_GENERAL, SHA256_HMAC_GEN_MECH_INFO_TYPE,
379 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
380 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
381 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
382 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
383 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
384 SHA2_HMAC_MIN_KEY_LEN, SHA2_HMAC_MAX_KEY_LEN,
385 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
386 /* SHA384 */
387 {SUN_CKM_SHA384, SHA384_MECH_INFO_TYPE,
388 CRYPTO_FG_DIGEST | CRYPTO_FG_DIGEST_ATOMIC, 0, 0,
389 CRYPTO_KEYSIZE_UNIT_IN_BITS},
390 /* SHA384-HMAC */
391 {SUN_CKM_SHA384_HMAC, SHA384_HMAC_MECH_INFO_TYPE,
392 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
393 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
394 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
395 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
396 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
397 SHA2_HMAC_MIN_KEY_LEN, SHA2_HMAC_MAX_KEY_LEN,
398 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
399 /* SHA384-HMAC GENERAL */
400 {SUN_CKM_SHA384_HMAC_GENERAL, SHA384_HMAC_GEN_MECH_INFO_TYPE,
401 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
402 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
403 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
404 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
405 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
406 SHA2_HMAC_MIN_KEY_LEN, SHA2_HMAC_MAX_KEY_LEN,
407 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
408 /* SHA512 */
409 {SUN_CKM_SHA512, SHA512_MECH_INFO_TYPE,
410 CRYPTO_FG_DIGEST | CRYPTO_FG_DIGEST_ATOMIC, 0, 0,
411 CRYPTO_KEYSIZE_UNIT_IN_BITS},
412 /* SHA512-HMAC */
413 {SUN_CKM_SHA512_HMAC, SHA512_HMAC_MECH_INFO_TYPE,
414 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
415 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
416 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
417 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
418 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
419 SHA2_HMAC_MIN_KEY_LEN, SHA2_HMAC_MAX_KEY_LEN,
420 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
421 /* SHA512-HMAC GENERAL */
422 {SUN_CKM_SHA512_HMAC_GENERAL, SHA512_HMAC_GEN_MECH_INFO_TYPE,
423 CRYPTO_FG_MAC | CRYPTO_FG_MAC_ATOMIC |
424 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
425 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
426 CRYPTO_FG_ENCRYPT_MAC | CRYPTO_FG_MAC_DECRYPT |
427 CRYPTO_FG_ENCRYPT_MAC_ATOMIC | CRYPTO_FG_MAC_DECRYPT_ATOMIC,
428 SHA2_HMAC_MIN_KEY_LEN, SHA2_HMAC_MAX_KEY_LEN,
429 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
430 /* DES-CBC */
431 {SUN_CKM_DES_CBC, DES_CBC_MECH_INFO_TYPE,
432 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
433 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
434 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
435 CRYPTO_FG_MAC_DECRYPT_ATOMIC,
436 DES_KEY_LEN, DES_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
437 /* DES3-CBC */
438 {SUN_CKM_DES3_CBC, DES3_CBC_MECH_INFO_TYPE,
439 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
440 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
441 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
442 CRYPTO_FG_MAC_DECRYPT_ATOMIC,
443 DES3_KEY_LEN, DES3_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
444 /* DES-ECB */
445 {SUN_CKM_DES_ECB, DES_ECB_MECH_INFO_TYPE,
446 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
447 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
448 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
449 CRYPTO_FG_MAC_DECRYPT_ATOMIC,
450 DES_KEY_LEN, DES_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
451 /* DES3-ECB */
452 {SUN_CKM_DES3_ECB, DES3_ECB_MECH_INFO_TYPE,
453 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
454 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
455 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
456 CRYPTO_FG_MAC_DECRYPT_ATOMIC,
457 DES3_KEY_LEN, DES3_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
458 /* BLOWFISH-CBC */
459 {SUN_CKM_BLOWFISH_CBC, BLOWFISH_CBC_MECH_INFO_TYPE,
460 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
461 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
462 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
463 CRYPTO_FG_MAC_DECRYPT_ATOMIC, BLOWFISH_MIN_KEY_LEN,
464 BLOWFISH_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
465 /* BLOWFISH-ECB */
466 {SUN_CKM_BLOWFISH_ECB, BLOWFISH_ECB_MECH_INFO_TYPE,
467 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
468 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
469 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
470 CRYPTO_FG_MAC_DECRYPT_ATOMIC, BLOWFISH_MIN_KEY_LEN,
471 BLOWFISH_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
472 /* AES-CBC */
473 {SUN_CKM_AES_CBC, AES_CBC_MECH_INFO_TYPE,
474 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
475 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
476 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
477 CRYPTO_FG_MAC_DECRYPT_ATOMIC,
478 AES_MIN_KEY_LEN, AES_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
479 /* AES-ECB */
480 {SUN_CKM_AES_ECB, AES_ECB_MECH_INFO_TYPE,
481 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
482 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
483 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
484 CRYPTO_FG_MAC_DECRYPT_ATOMIC,
485 AES_MIN_KEY_LEN, AES_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
486 /* AES-CTR */
487 {SUN_CKM_AES_CTR, AES_CTR_MECH_INFO_TYPE,
488 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
489 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
490 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
491 CRYPTO_FG_MAC_DECRYPT_ATOMIC,
492 AES_MIN_KEY_LEN, AES_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
493 /* AES-CCM */
494 {SUN_CKM_AES_CCM, AES_CCM_MECH_INFO_TYPE,
495 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
496 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
497 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
498 CRYPTO_FG_MAC_DECRYPT_ATOMIC,
499 AES_MIN_KEY_LEN, AES_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
500 /* AES-GCM */
501 {SUN_CKM_AES_GCM, AES_GCM_MECH_INFO_TYPE,
502 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
503 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
504 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
505 CRYPTO_FG_MAC_DECRYPT_ATOMIC,
506 AES_MIN_KEY_LEN, AES_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
507 /* AES-GMAC */
508 {SUN_CKM_AES_GMAC, AES_GMAC_MECH_INFO_TYPE,
509 CRYPTO_FG_ENCRYPT | CRYPTO_FG_DECRYPT | CRYPTO_FG_ENCRYPT_MAC |
510 CRYPTO_FG_MAC_DECRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
511 CRYPTO_FG_DECRYPT_ATOMIC | CRYPTO_FG_ENCRYPT_MAC_ATOMIC |
512 CRYPTO_FG_MAC_DECRYPT_ATOMIC |
513 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
514 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC,
515 AES_MIN_KEY_LEN, AES_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BYTES},
516 /* RC4 */
517 {SUN_CKM_RC4, RC4_MECH_INFO_TYPE,
518 CRYPTO_FG_ENCRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
519 CRYPTO_FG_DECRYPT | CRYPTO_FG_DECRYPT_ATOMIC,
520 ARCFOUR_MIN_KEY_BITS, ARCFOUR_MAX_KEY_BITS,
521 CRYPTO_KEYSIZE_UNIT_IN_BITS | CRYPTO_CAN_SHARE_OPSTATE},
522 /* RSA_PKCS */
523 {SUN_CKM_RSA_PKCS, RSA_PKCS_MECH_INFO_TYPE,
524 CRYPTO_FG_ENCRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
525 CRYPTO_FG_DECRYPT | CRYPTO_FG_DECRYPT_ATOMIC |
526 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
527 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
528 CRYPTO_FG_SIGN_RECOVER | CRYPTO_FG_SIGN_RECOVER_ATOMIC |
529 CRYPTO_FG_VERIFY_RECOVER | CRYPTO_FG_VERIFY_RECOVER_ATOMIC,
530 RSA_MIN_KEY_LEN, RSA_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
531 /* RSA_X_509 */
532 {SUN_CKM_RSA_X_509, RSA_X_509_MECH_INFO_TYPE,
533 CRYPTO_FG_ENCRYPT | CRYPTO_FG_ENCRYPT_ATOMIC |
534 CRYPTO_FG_DECRYPT | CRYPTO_FG_DECRYPT_ATOMIC |
535 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
536 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC |
537 CRYPTO_FG_SIGN_RECOVER | CRYPTO_FG_SIGN_RECOVER_ATOMIC |
538 CRYPTO_FG_VERIFY_RECOVER | CRYPTO_FG_VERIFY_RECOVER_ATOMIC,
539 RSA_MIN_KEY_LEN, RSA_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
540 /* MD5_RSA_PKCS */
541 {SUN_CKM_MD5_RSA_PKCS, MD5_RSA_PKCS_MECH_INFO_TYPE,
542 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
543 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC,
544 RSA_MIN_KEY_LEN, RSA_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
545 /* SHA1_RSA_PKCS */
546 {SUN_CKM_SHA1_RSA_PKCS, SHA1_RSA_PKCS_MECH_INFO_TYPE,
547 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
548 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC,
549 RSA_MIN_KEY_LEN, RSA_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
550 /* SHA256_RSA_PKCS */
551 {SUN_CKM_SHA256_RSA_PKCS, SHA256_RSA_PKCS_MECH_INFO_TYPE,
552 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
553 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC,
554 RSA_MIN_KEY_LEN, RSA_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
555 /* SHA384_RSA_PKCS */
556 {SUN_CKM_SHA384_RSA_PKCS, SHA384_RSA_PKCS_MECH_INFO_TYPE,
557 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
558 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC,
559 RSA_MIN_KEY_LEN, RSA_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
560 /* SHA512_RSA_PKCS */
561 {SUN_CKM_SHA512_RSA_PKCS, SHA512_RSA_PKCS_MECH_INFO_TYPE,
562 CRYPTO_FG_SIGN | CRYPTO_FG_SIGN_ATOMIC |
563 CRYPTO_FG_VERIFY | CRYPTO_FG_VERIFY_ATOMIC,
564 RSA_MIN_KEY_LEN, RSA_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
565 /* MD5_KEY_DERIVATION */
566 {DPROV_CKM_MD5_KEY_DERIVATION, MD5_KEY_DERIVATION_MECH_INFO_TYPE,
567 CRYPTO_FG_DERIVE, 0, 0, CRYPTO_KEYSIZE_UNIT_IN_BITS},
568 /* SHA1_KEY_DERIVATION */
569 {DPROV_CKM_SHA1_KEY_DERIVATION, SHA1_KEY_DERIVATION_MECH_INFO_TYPE,
570 CRYPTO_FG_DERIVE, 0, 0, CRYPTO_KEYSIZE_UNIT_IN_BITS},
571 /* SHA256_KEY_DERIVATION */
572 {DPROV_CKM_SHA256_KEY_DERIVATION, SHA256_KEY_DERIVATION_MECH_INFO_TYPE,
573 CRYPTO_FG_DERIVE, 0, 0, CRYPTO_KEYSIZE_UNIT_IN_BITS},
574 /* SHA384_KEY_DERIVATION */
575 {DPROV_CKM_SHA384_KEY_DERIVATION, SHA384_KEY_DERIVATION_MECH_INFO_TYPE,
576 CRYPTO_FG_DERIVE, 0, 0, CRYPTO_KEYSIZE_UNIT_IN_BITS},
577 /* SHA512_KEY_DERIVATION */
578 {DPROV_CKM_SHA512_KEY_DERIVATION, SHA512_KEY_DERIVATION_MECH_INFO_TYPE,
579 CRYPTO_FG_DERIVE, 0, 0, CRYPTO_KEYSIZE_UNIT_IN_BITS},
580 /* DES_KEY_GENERATION */
581 {DPROV_CKM_DES_KEY_GEN, DES_KEY_GEN_MECH_INFO_TYPE,
582 CRYPTO_FG_GENERATE, DES_KEY_LEN, DES_KEY_LEN,
583 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
584 /* DES3_KEY_GENERATION */
585 {DPROV_CKM_DES3_KEY_GEN, DES3_KEY_GEN_MECH_INFO_TYPE,
586 CRYPTO_FG_GENERATE, DES3_KEY_LEN, DES3_KEY_LEN,
587 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
588 /* AES_KEY_GENERATION */
589 {DPROV_CKM_AES_KEY_GEN, AES_KEY_GEN_MECH_INFO_TYPE,
590 CRYPTO_FG_GENERATE, AES_MIN_KEY_LEN, AES_MAX_KEY_LEN,
591 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
592 /* BLOWFISH_KEY_GENERATION */
593 {DPROV_CKM_BLOWFISH_KEY_GEN, BLOWFISH_KEY_GEN_MECH_INFO_TYPE,
594 CRYPTO_FG_GENERATE, BLOWFISH_MIN_KEY_LEN, BLOWFISH_MAX_KEY_LEN,
595 CRYPTO_KEYSIZE_UNIT_IN_BYTES},
596 /* RC4_KEY_GENERATION */
597 {DPROV_CKM_RC4_KEY_GEN, RC4_KEY_GEN_MECH_INFO_TYPE,
598 CRYPTO_FG_GENERATE, ARCFOUR_MIN_KEY_BITS, ARCFOUR_MAX_KEY_BITS,
599 CRYPTO_KEYSIZE_UNIT_IN_BITS},
600 /* DH_PKCS_KEY_PAIR_GEN */
601 {DPROV_CKM_DH_PKCS_KEY_PAIR_GEN, DH_PKCS_KEY_PAIR_GEN_MECH_INFO_TYPE,
602 CRYPTO_FG_GENERATE_KEY_PAIR, DH_MIN_KEY_LEN, DH_MAX_KEY_LEN,
603 CRYPTO_KEYSIZE_UNIT_IN_BITS},
604 /* DH_PKCS_DERIVE */
605 {DPROV_CKM_DH_PKCS_DERIVE, DH_PKCS_DERIVE_MECH_INFO_TYPE,
606 CRYPTO_FG_DERIVE, 0, 0, CRYPTO_KEYSIZE_UNIT_IN_BITS},
607 /* RSA_PKCS_KEY_PAIR_GEN */
608 {DPROV_CKM_RSA_PKCS_KEY_PAIR_GEN, RSA_PKCS_KEY_PAIR_GEN_MECH_INFO_TYPE,
609 CRYPTO_FG_GENERATE_KEY_PAIR, RSA_MIN_KEY_LEN, RSA_MAX_KEY_LEN,
610 CRYPTO_KEYSIZE_UNIT_IN_BITS},
611 /* EC_KEY_PAIR_GEN */
612 {DPROV_CKM_EC_KEY_PAIR_GEN, EC_KEY_PAIR_GEN_MECH_INFO_TYPE,
613 CRYPTO_FG_GENERATE_KEY_PAIR, EC_MIN_KEY_LEN, EC_MAX_KEY_LEN,
614 CRYPTO_KEYSIZE_UNIT_IN_BITS},
615 /* ECDSA */
616 {DPROV_CKM_ECDSA, ECDSA_MECH_INFO_TYPE,
617 CRYPTO_FG_SIGN | CRYPTO_FG_VERIFY |
618 CRYPTO_FG_SIGN_ATOMIC | CRYPTO_FG_VERIFY_ATOMIC |
619 EC_MIN_KEY_LEN, EC_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
620 /* ECDSA_SHA1 */
621 {DPROV_CKM_ECDSA_SHA1, ECDSA_SHA1_MECH_INFO_TYPE,
622 CRYPTO_FG_SIGN | CRYPTO_FG_VERIFY |
623 CRYPTO_FG_SIGN_ATOMIC | CRYPTO_FG_VERIFY_ATOMIC |
624 EC_MIN_KEY_LEN, EC_MAX_KEY_LEN, CRYPTO_KEYSIZE_UNIT_IN_BITS},
625 /* ECDH1_DERIVE */
626 {DPROV_CKM_ECDH1_DERIVE, ECDH1_DERIVE_MECH_INFO_TYPE,
627 CRYPTO_FG_DERIVE, 0, 0, CRYPTO_KEYSIZE_UNIT_IN_BITS}
628 };
629
630 /*
631 * Crypto Values
632 *
633 * These values are the used in the STC ef test suite. If they are changed
634 * the test suite needs to be changed.
635 */
636 static uchar_t dh_value[8] = { 'd', 'h', 'd', 'h', 'd', 'h', 'd', '\0' };
637 char public_exponent[3] = { 0x01, 0x00, 0x01 };
638 static uchar_t private_exponent[128] = {
639 0x8e, 0xc9, 0x70, 0x57, 0x6b, 0xcd, 0xfb, 0xa9,
640 0x19, 0xad, 0xcd, 0x91, 0x69, 0xd5, 0x52, 0xec,
641 0x72, 0x1e, 0x45, 0x15, 0x06, 0xdc, 0x65, 0x2d,
642 0x98, 0xc4, 0xce, 0x33, 0x54, 0x15, 0x70, 0x8d,
643 0xfa, 0x65, 0xea, 0x53, 0x44, 0xf3, 0x3e, 0x3f,
644 0xb4, 0x4c, 0x60, 0xd5, 0x01, 0x2d, 0xa4, 0x12,
645 0x99, 0xbf, 0x3f, 0x0b, 0xcd, 0xbb, 0x24, 0x10,
646 0x60, 0x30, 0x5e, 0x58, 0xf8, 0x59, 0xaa, 0xd1,
647 0x63, 0x3b, 0xbc, 0xcb, 0x94, 0x58, 0x38, 0x24,
648 0xfc, 0x65, 0x25, 0xc5, 0xa6, 0x51, 0xa2, 0x2e,
649 0xf1, 0x5e, 0xf5, 0xc1, 0xf5, 0x46, 0xf7, 0xbd,
650 0xc7, 0x62, 0xa8, 0xe2, 0x27, 0xd6, 0x94, 0x5b,
651 0xd3, 0xa2, 0xb5, 0x76, 0x42, 0x67, 0x6b, 0x86,
652 0x91, 0x97, 0x4d, 0x07, 0x92, 0x00, 0x4a, 0xdf,
653 0x0b, 0x65, 0x64, 0x05, 0x03, 0x48, 0x27, 0xeb,
654 0xce, 0x9a, 0x49, 0x7f, 0x3e, 0x10, 0xe0, 0x01
655 };
656
657 static uchar_t modulus[128] = {
658 0x94, 0x32, 0xb9, 0x12, 0x1d, 0x68, 0x2c, 0xda,
659 0x2b, 0xe0, 0xe4, 0x97, 0x1b, 0x4d, 0xdc, 0x43,
660 0xdf, 0x38, 0x6e, 0x7b, 0x9f, 0x07, 0x58, 0xae,
661 0x9d, 0x82, 0x1e, 0xc7, 0xbc, 0x92, 0xbf, 0xd3,
662 0xce, 0x00, 0xbb, 0x91, 0xc9, 0x79, 0x06, 0x03,
663 0x1f, 0xbc, 0x9f, 0x94, 0x75, 0x29, 0x5f, 0xd7,
664 0xc5, 0xf3, 0x73, 0x8a, 0xa4, 0x35, 0x43, 0x7a,
665 0x00, 0x32, 0x97, 0x3e, 0x86, 0xef, 0x70, 0x6f,
666 0x18, 0x56, 0x15, 0xaa, 0x6a, 0x87, 0xe7, 0x8d,
667 0x7d, 0xdd, 0x1f, 0xa4, 0xe4, 0x31, 0xd4, 0x7a,
668 0x8c, 0x0e, 0x20, 0xd2, 0x23, 0xf5, 0x57, 0x3c,
669 0x1b, 0xa8, 0x44, 0xa4, 0x57, 0x8f, 0x33, 0x52,
670 0xad, 0x83, 0xae, 0x4a, 0x97, 0xa6, 0x1e, 0xa6,
671 0x2b, 0xfa, 0xea, 0xeb, 0x6e, 0x71, 0xb8, 0xb6,
672 0x0a, 0x36, 0xed, 0x83, 0xce, 0xb0, 0xdf, 0xc1,
673 0xd4, 0x3a, 0xe9, 0x99, 0x6f, 0xf3, 0x96, 0xb7
674 };
675
676
677 static void dprov_provider_status(crypto_provider_handle_t, uint_t *);
678
679 static crypto_control_ops_t dprov_control_ops = {
680 dprov_provider_status
681 };
682
683 #define DPROV_MANUFACTURER "SUNW "
684 #define DPROV_MODEL "dprov "
685 #define DPROV_ALLSPACES " "
686
687 static int dprov_digest_init(crypto_ctx_t *, crypto_mechanism_t *,
688 crypto_req_handle_t);
689 static int dprov_digest(crypto_ctx_t *, crypto_data_t *, crypto_data_t *,
690 crypto_req_handle_t);
691 static int dprov_digest_update(crypto_ctx_t *, crypto_data_t *,
692 crypto_req_handle_t);
693 static int dprov_digest_key(crypto_ctx_t *, crypto_key_t *,
694 crypto_req_handle_t);
695 static int dprov_digest_final(crypto_ctx_t *, crypto_data_t *,
696 crypto_req_handle_t);
697 static int dprov_digest_atomic(crypto_provider_handle_t, crypto_session_id_t,
698 crypto_mechanism_t *, crypto_data_t *, crypto_data_t *,
699 crypto_req_handle_t);
700
701 static crypto_digest_ops_t dprov_digest_ops = {
702 dprov_digest_init,
703 dprov_digest,
704 dprov_digest_update,
705 dprov_digest_key,
706 dprov_digest_final,
707 dprov_digest_atomic
708 };
709
710 static int dprov_mac_init(crypto_ctx_t *, crypto_mechanism_t *, crypto_key_t *,
711 crypto_spi_ctx_template_t, crypto_req_handle_t);
712 static int dprov_mac(crypto_ctx_t *, crypto_data_t *, crypto_data_t *,
713 crypto_req_handle_t);
714 static int dprov_mac_update(crypto_ctx_t *, crypto_data_t *,
715 crypto_req_handle_t);
716 static int dprov_mac_final(crypto_ctx_t *, crypto_data_t *,
717 crypto_req_handle_t);
718 static int dprov_mac_atomic(crypto_provider_handle_t, crypto_session_id_t,
719 crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
720 crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
721 static int dprov_mac_verify_atomic(crypto_provider_handle_t,
722 crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
723 crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
724
725 static crypto_mac_ops_t dprov_mac_ops = {
726 dprov_mac_init,
727 dprov_mac,
728 dprov_mac_update,
729 dprov_mac_final,
730 dprov_mac_atomic,
731 dprov_mac_verify_atomic
732 };
733
734 static int dprov_encrypt_init(crypto_ctx_t *, crypto_mechanism_t *,
735 crypto_key_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
736 static int dprov_encrypt(crypto_ctx_t *, crypto_data_t *, crypto_data_t *,
737 crypto_req_handle_t);
738 static int dprov_encrypt_update(crypto_ctx_t *, crypto_data_t *,
739 crypto_data_t *, crypto_req_handle_t);
740 static int dprov_encrypt_final(crypto_ctx_t *, crypto_data_t *,
741 crypto_req_handle_t);
742 static int dprov_encrypt_atomic(crypto_provider_handle_t, crypto_session_id_t,
743 crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
744 crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
745
746 static int dprov_decrypt_init(crypto_ctx_t *, crypto_mechanism_t *,
747 crypto_key_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
748 static int dprov_decrypt(crypto_ctx_t *, crypto_data_t *, crypto_data_t *,
749 crypto_req_handle_t);
750 static int dprov_decrypt_update(crypto_ctx_t *, crypto_data_t *,
751 crypto_data_t *, crypto_req_handle_t);
752 static int dprov_decrypt_final(crypto_ctx_t *, crypto_data_t *,
753 crypto_req_handle_t);
754 static int dprov_decrypt_atomic(crypto_provider_handle_t, crypto_session_id_t,
755 crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
756 crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
757
758 static crypto_cipher_ops_t dprov_cipher_ops = {
759 dprov_encrypt_init,
760 dprov_encrypt,
761 dprov_encrypt_update,
762 dprov_encrypt_final,
763 dprov_encrypt_atomic,
764 dprov_decrypt_init,
765 dprov_decrypt,
766 dprov_decrypt_update,
767 dprov_decrypt_final,
768 dprov_decrypt_atomic
769 };
770
771 static int dprov_sign_init(crypto_ctx_t *, crypto_mechanism_t *, crypto_key_t *,
772 crypto_spi_ctx_template_t, crypto_req_handle_t);
773 static int dprov_sign(crypto_ctx_t *, crypto_data_t *, crypto_data_t *,
774 crypto_req_handle_t);
775 static int dprov_sign_update(crypto_ctx_t *, crypto_data_t *,
776 crypto_req_handle_t);
777 static int dprov_sign_final(crypto_ctx_t *, crypto_data_t *,
778 crypto_req_handle_t);
779 static int dprov_sign_atomic(crypto_provider_handle_t, crypto_session_id_t,
780 crypto_mechanism_t *, crypto_key_t *, crypto_data_t *, crypto_data_t *,
781 crypto_spi_ctx_template_t, crypto_req_handle_t);
782 static int dprov_sign_recover_init(crypto_ctx_t *, crypto_mechanism_t *,
783 crypto_key_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
784 static int dprov_sign_recover(crypto_ctx_t *, crypto_data_t *, crypto_data_t *,
785 crypto_req_handle_t);
786 static int dprov_sign_recover_atomic(crypto_provider_handle_t,
787 crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *,
788 crypto_data_t *, crypto_data_t *, crypto_spi_ctx_template_t,
789 crypto_req_handle_t);
790
791 static crypto_sign_ops_t dprov_sign_ops = {
792 dprov_sign_init,
793 dprov_sign,
794 dprov_sign_update,
795 dprov_sign_final,
796 dprov_sign_atomic,
797 dprov_sign_recover_init,
798 dprov_sign_recover,
799 dprov_sign_recover_atomic
800 };
801
802 static int dprov_verify_init(crypto_ctx_t *, crypto_mechanism_t *,
803 crypto_key_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
804 static int dprov_verify(crypto_ctx_t *, crypto_data_t *, crypto_data_t *,
805 crypto_req_handle_t);
806 static int dprov_verify_update(crypto_ctx_t *, crypto_data_t *,
807 crypto_req_handle_t);
808 static int dprov_verify_final(crypto_ctx_t *, crypto_data_t *,
809 crypto_req_handle_t);
810 static int dprov_verify_atomic(crypto_provider_handle_t, crypto_session_id_t,
811 crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
812 crypto_data_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
813 static int dprov_verify_recover_init(crypto_ctx_t *, crypto_mechanism_t *,
814 crypto_key_t *, crypto_spi_ctx_template_t, crypto_req_handle_t);
815 static int dprov_verify_recover(crypto_ctx_t *, crypto_data_t *,
816 crypto_data_t *, crypto_req_handle_t);
817 static int dprov_verify_recover_atomic(crypto_provider_handle_t,
818 crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *,
819 crypto_data_t *, crypto_data_t *, crypto_spi_ctx_template_t,
820 crypto_req_handle_t);
821
822 static crypto_verify_ops_t dprov_verify_ops = {
823 dprov_verify_init,
824 dprov_verify,
825 dprov_verify_update,
826 dprov_verify_final,
827 dprov_verify_atomic,
828 dprov_verify_recover_init,
829 dprov_verify_recover,
830 dprov_verify_recover_atomic
831 };
832
833 static int dprov_digest_encrypt_update(crypto_ctx_t *, crypto_ctx_t *,
834 crypto_data_t *, crypto_data_t *, crypto_req_handle_t);
835 static int dprov_decrypt_digest_update(crypto_ctx_t *, crypto_ctx_t *,
836 crypto_data_t *, crypto_data_t *, crypto_req_handle_t);
837 static int dprov_sign_encrypt_update(crypto_ctx_t *, crypto_ctx_t *,
838 crypto_data_t *, crypto_data_t *, crypto_req_handle_t);
839 static int dprov_decrypt_verify_update(crypto_ctx_t *, crypto_ctx_t *,
840 crypto_data_t *, crypto_data_t *, crypto_req_handle_t);
841
842 static crypto_dual_ops_t dprov_dual_ops = {
843 dprov_digest_encrypt_update,
844 dprov_decrypt_digest_update,
845 dprov_sign_encrypt_update,
846 dprov_decrypt_verify_update
847 };
848
849 static int dprov_encrypt_mac_init(crypto_ctx_t *,
850 crypto_mechanism_t *, crypto_key_t *, crypto_mechanism_t *,
851 crypto_key_t *, crypto_spi_ctx_template_t,
852 crypto_spi_ctx_template_t, crypto_req_handle_t);
853 static int dprov_encrypt_mac(crypto_ctx_t *,
854 crypto_data_t *, crypto_dual_data_t *, crypto_data_t *,
855 crypto_req_handle_t);
856 static int dprov_encrypt_mac_update(crypto_ctx_t *,
857 crypto_data_t *, crypto_dual_data_t *, crypto_req_handle_t);
858 static int dprov_encrypt_mac_final(crypto_ctx_t *,
859 crypto_dual_data_t *, crypto_data_t *, crypto_req_handle_t);
860 static int dprov_encrypt_mac_atomic(crypto_provider_handle_t,
861 crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *,
862 crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
863 crypto_dual_data_t *, crypto_data_t *, crypto_spi_ctx_template_t,
864 crypto_spi_ctx_template_t, crypto_req_handle_t);
865
866 static int dprov_mac_decrypt_init(crypto_ctx_t *,
867 crypto_mechanism_t *, crypto_key_t *, crypto_mechanism_t *,
868 crypto_key_t *, crypto_spi_ctx_template_t,
869 crypto_spi_ctx_template_t, crypto_req_handle_t);
870 static int dprov_mac_decrypt(crypto_ctx_t *,
871 crypto_dual_data_t *, crypto_data_t *, crypto_data_t *,
872 crypto_req_handle_t);
873 static int dprov_mac_decrypt_update(crypto_ctx_t *,
874 crypto_dual_data_t *, crypto_data_t *, crypto_req_handle_t);
875 static int dprov_mac_decrypt_final(crypto_ctx_t *,
876 crypto_data_t *, crypto_data_t *, crypto_req_handle_t);
877 static int dprov_mac_decrypt_atomic(crypto_provider_handle_t,
878 crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *,
879 crypto_mechanism_t *, crypto_key_t *, crypto_dual_data_t *,
880 crypto_data_t *, crypto_data_t *, crypto_spi_ctx_template_t,
881 crypto_spi_ctx_template_t, crypto_req_handle_t);
882 static int dprov_mac_verify_decrypt_atomic(crypto_provider_handle_t,
883 crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *,
884 crypto_mechanism_t *, crypto_key_t *, crypto_dual_data_t *,
885 crypto_data_t *, crypto_data_t *, crypto_spi_ctx_template_t,
886 crypto_spi_ctx_template_t, crypto_req_handle_t);
887
888 static crypto_dual_cipher_mac_ops_t dprov_cipher_mac_ops = {
889 dprov_encrypt_mac_init,
890 dprov_encrypt_mac,
891 dprov_encrypt_mac_update,
892 dprov_encrypt_mac_final,
893 dprov_encrypt_mac_atomic,
894 dprov_mac_decrypt_init,
895 dprov_mac_decrypt,
896 dprov_mac_decrypt_update,
897 dprov_mac_decrypt_final,
898 dprov_mac_decrypt_atomic,
899 dprov_mac_verify_decrypt_atomic
900 };
901
902 static int dprov_seed_random(crypto_provider_handle_t, crypto_session_id_t,
903 uchar_t *, size_t, uint_t, uint32_t, crypto_req_handle_t);
904 static int dprov_generate_random(crypto_provider_handle_t, crypto_session_id_t,
905 uchar_t *, size_t, crypto_req_handle_t);
906
907 static crypto_random_number_ops_t dprov_random_number_ops = {
908 dprov_seed_random,
909 dprov_generate_random
910 };
911
912 static int dprov_session_open(crypto_provider_handle_t, crypto_session_id_t *,
913 crypto_req_handle_t);
914 static int dprov_session_close(crypto_provider_handle_t, crypto_session_id_t,
915 crypto_req_handle_t);
916 static int dprov_session_login(crypto_provider_handle_t, crypto_session_id_t,
917 crypto_user_type_t, char *, size_t, crypto_req_handle_t);
918 static int dprov_session_logout(crypto_provider_handle_t, crypto_session_id_t,
919 crypto_req_handle_t);
920
921 static crypto_session_ops_t dprov_session_ops = {
922 dprov_session_open,
923 dprov_session_close,
924 dprov_session_login,
925 dprov_session_logout
926 };
927
928 static int dprov_object_create(crypto_provider_handle_t, crypto_session_id_t,
929 crypto_object_attribute_t *, uint_t, crypto_object_id_t *,
930 crypto_req_handle_t);
931 static int dprov_object_copy(crypto_provider_handle_t, crypto_session_id_t,
932 crypto_object_id_t, crypto_object_attribute_t *, uint_t,
933 crypto_object_id_t *, crypto_req_handle_t);
934 static int dprov_object_destroy(crypto_provider_handle_t, crypto_session_id_t,
935 crypto_object_id_t, crypto_req_handle_t);
936 static int dprov_object_get_size(crypto_provider_handle_t, crypto_session_id_t,
937 crypto_object_id_t, size_t *, crypto_req_handle_t);
938 static int dprov_object_get_attribute_value(crypto_provider_handle_t,
939 crypto_session_id_t, crypto_object_id_t,
940 crypto_object_attribute_t *, uint_t, crypto_req_handle_t);
941 static int dprov_object_set_attribute_value(crypto_provider_handle_t,
942 crypto_session_id_t, crypto_object_id_t,
943 crypto_object_attribute_t *, uint_t, crypto_req_handle_t);
944 static int dprov_object_find_init(crypto_provider_handle_t, crypto_session_id_t,
945 crypto_object_attribute_t *, uint_t, void **,
946 crypto_req_handle_t);
947 static int dprov_object_find(crypto_provider_handle_t, void *,
948 crypto_object_id_t *, uint_t, uint_t *, crypto_req_handle_t);
949 static int dprov_object_find_final(crypto_provider_handle_t, void *,
950 crypto_req_handle_t);
951
952 static crypto_object_ops_t dprov_object_ops = {
953 dprov_object_create,
954 dprov_object_copy,
955 dprov_object_destroy,
956 dprov_object_get_size,
957 dprov_object_get_attribute_value,
958 dprov_object_set_attribute_value,
959 dprov_object_find_init,
960 dprov_object_find,
961 dprov_object_find_final
962 };
963
964 static int dprov_key_generate(crypto_provider_handle_t, crypto_session_id_t,
965 crypto_mechanism_t *, crypto_object_attribute_t *, uint_t,
966 crypto_object_id_t *, crypto_req_handle_t);
967 static int dprov_key_generate_pair(crypto_provider_handle_t,
968 crypto_session_id_t, crypto_mechanism_t *, crypto_object_attribute_t *,
969 uint_t, crypto_object_attribute_t *, uint_t, crypto_object_id_t *,
970 crypto_object_id_t *, crypto_req_handle_t);
971 static int dprov_key_wrap(crypto_provider_handle_t, crypto_session_id_t,
972 crypto_mechanism_t *, crypto_key_t *, crypto_object_id_t *,
973 uchar_t *, size_t *, crypto_req_handle_t);
974 static int dprov_key_unwrap(crypto_provider_handle_t, crypto_session_id_t,
975 crypto_mechanism_t *, crypto_key_t *, uchar_t *, size_t *,
976 crypto_object_attribute_t *, uint_t,
977 crypto_object_id_t *, crypto_req_handle_t);
978 static int dprov_key_derive(crypto_provider_handle_t, crypto_session_id_t,
979 crypto_mechanism_t *, crypto_key_t *, crypto_object_attribute_t *,
980 uint_t, crypto_object_id_t *, crypto_req_handle_t);
981
982 static crypto_key_ops_t dprov_key_ops = {
983 dprov_key_generate,
984 dprov_key_generate_pair,
985 dprov_key_wrap,
986 dprov_key_unwrap,
987 dprov_key_derive
988 };
989
990 static int dprov_ext_info(crypto_provider_handle_t,
991 crypto_provider_ext_info_t *, crypto_req_handle_t);
992 static int dprov_init_token(crypto_provider_handle_t, char *, size_t,
993 char *, crypto_req_handle_t);
994 static int dprov_init_pin(crypto_provider_handle_t, crypto_session_id_t,
995 char *, size_t, crypto_req_handle_t);
996 static int dprov_set_pin(crypto_provider_handle_t, crypto_session_id_t,
997 char *, size_t, char *, size_t, crypto_req_handle_t);
998
999 static crypto_provider_management_ops_t dprov_management_ops = {
1000 dprov_ext_info,
1001 dprov_init_token,
1002 dprov_init_pin,
1003 dprov_set_pin
1004 };
1005
1006 static int dprov_free_context(crypto_ctx_t *);
1007 static int dprov_copyin_mechanism(crypto_provider_handle_t,
1008 crypto_mechanism_t *, crypto_mechanism_t *, int *error, int);
1009 static int dprov_copyout_mechanism(crypto_provider_handle_t,
1010 crypto_mechanism_t *, crypto_mechanism_t *, int *error, int);
1011 static int dprov_free_mechanism(crypto_provider_handle_t,
1012 crypto_mechanism_t *);
1013
1014 static crypto_ctx_ops_t dprov_ctx_ops = {
1015 NULL,
1016 dprov_free_context
1017 };
1018
1019 static crypto_mech_ops_t dprov_mech_ops = {
1020 dprov_copyin_mechanism,
1021 dprov_copyout_mechanism,
1022 dprov_free_mechanism
1023 };
1024
1025 static int dprov_nostore_key_generate(crypto_provider_handle_t,
1026 crypto_session_id_t, crypto_mechanism_t *, crypto_object_attribute_t *,
1027 uint_t, crypto_object_attribute_t *, uint_t, crypto_req_handle_t);
1028 static int dprov_nostore_key_generate_pair(crypto_provider_handle_t,
1029 crypto_session_id_t, crypto_mechanism_t *, crypto_object_attribute_t *,
1030 uint_t, crypto_object_attribute_t *, uint_t, crypto_object_attribute_t *,
1031 uint_t, crypto_object_attribute_t *, uint_t, crypto_req_handle_t);
1032 static int dprov_nostore_key_derive(crypto_provider_handle_t,
1033 crypto_session_id_t, crypto_mechanism_t *, crypto_key_t *,
1034 crypto_object_attribute_t *, uint_t, crypto_object_attribute_t *,
1035 uint_t, crypto_req_handle_t);
1036
1037 static crypto_nostore_key_ops_t dprov_nostore_key_ops = {
1038 dprov_nostore_key_generate,
1039 dprov_nostore_key_generate_pair,
1040 dprov_nostore_key_derive
1041 };
1042
1043 static crypto_ops_t dprov_crypto_ops = {
1044 &dprov_control_ops,
1045 &dprov_digest_ops,
1046 &dprov_cipher_ops,
1047 &dprov_mac_ops,
1048 &dprov_sign_ops,
1049 &dprov_verify_ops,
1050 &dprov_dual_ops,
1051 &dprov_cipher_mac_ops,
1052 &dprov_random_number_ops,
1053 &dprov_session_ops,
1054 &dprov_object_ops,
1055 &dprov_key_ops,
1056 &dprov_management_ops,
1057 &dprov_ctx_ops,
1058 &dprov_mech_ops
1059 };
1060
1061
1062 /* maximum SO and user PIN lengths */
1063 #define DPROV_MAX_PIN_LEN 128
1064
1065 /*
1066 * Objects: each session is associated with an array of objects.
1067 * Unlike PKCS#11, the objects cannot be shared between sessions.
1068 * The ioctl driver multiplexes PKCS#11 sessions to providers
1069 * sessions in order to support this semantic. This simplifies
1070 * the CSPI greatly since the provider does not have to associate
1071 * sessions with a user space process.
1072 * There is also a per-instance array of objects, which correspond
1073 * to PKCS#11 token objects. These objects can be shared by multiple
1074 * sesions.
1075 *
1076 * Token objects are identified by having a CKA_TOKEN attribute B_TRUE.
1077 * Private objects are identified by having a CKA_PRIVATE attribute
1078 * set to B_TRUE.
1079 */
1080
1081 #define DPROV_MAX_OBJECTS 128 /* max # of objects */
1082 #define DPROV_MAX_ATTR 64 /* max # of attributes per object */
1083
1084 /* object description */
1085 typedef struct dprov_object {
1086 crypto_object_attribute_t do_attr[DPROV_MAX_ATTR]; /* attributes */
1087 uint_t do_token_idx; /* index in per-instance table */
1088 /* for token objects. */
1089 boolean_t do_destroyed; /* object has been destroyed. */
1090 /* keep object around until all */
1091 /* sessions that refer to it */
1092 /* are closed, but mark it */
1093 /* destroyed so that references */
1094 /* to the object fail. */
1095 /* used for token objects only */
1096 uint_t do_refcnt;
1097 } dprov_object_t;
1098
1099 /*
1100 * If a session has a reference to a dprov_object_t,
1101 * it REFHOLD()s.
1102 */
1103 #define DPROV_OBJECT_REFHOLD(object) { \
1104 atomic_inc_32(&(object)->do_refcnt); \
1105 ASSERT((object)->do_refcnt != 0); \
1106 }
1107
1108 /*
1109 * Releases a reference to an object. When the last
1110 * reference is released, the object is freed.
1111 */
1112 #define DPROV_OBJECT_REFRELE(object) { \
1113 ASSERT((object)->do_refcnt != 0); \
1114 membar_exit(); \
1115 if (atomic_dec_32_nv(&(object)->do_refcnt) == 0) \
1116 dprov_free_object(object); \
1117 }
1118
1119 /*
1120 * Object attributes are passed to the provider using crypto_object_attribute
1121 * structures, which contain the type of the attribute, a pointer to
1122 * it's value, and the length of its value. The attribute types values
1123 * are defined by the PKCS#11 specification. This provider only cares
1124 * about a subset of these attributes. In order to avoid having to
1125 * include the PKCS#11 header files, we define here the attributes values
1126 * which are used by the provider.
1127 */
1128
1129 #define DPROV_CKA_CLASS 0x00000000
1130 #define DPROV_CKA_TOKEN 0x00000001
1131 #define DPROV_CKA_PRIVATE 0x00000002
1132 #define DPROV_CKA_VALUE 0x00000011
1133 #define DPROV_CKA_CERTIFICATE_TYPE 0x00000080
1134 #define DPROV_CKA_KEY_TYPE 0x00000100
1135 #define DPROV_CKA_SENSITIVE 0x00000103
1136 #define DPROV_CKA_ENCRYPT 0x00000104
1137 #define DPROV_CKA_DECRYPT 0x00000105
1138 #define DPROV_CKA_WRAP 0x00000106
1139 #define DPROV_CKA_UNWRAP 0x00000107
1140 #define DPROV_CKA_SIGN 0x00000108
1141 #define DPROV_CKA_SIGN_RECOVER 0x00000109
1142 #define DPROV_CKA_VERIFY 0x0000010A
1143 #define DPROV_CKA_VERIFY_RECOVER 0x0000010B
1144 #define DPROV_CKA_DERIVE 0x0000010C
1145 #define DPROV_CKA_MODULUS 0x00000120
1146 #define DPROV_CKA_MODULUS_BITS 0x00000121
1147 #define DPROV_CKA_PUBLIC_EXPONENT 0x00000122
1148 #define DPROV_CKA_PRIVATE_EXPONENT 0x00000123
1149 #define DPROV_CKA_PRIME 0x00000130
1150 #define DPROV_CKA_BASE 0x00000132
1151 #define DPROV_CKA_VALUE_BITS 0x00000160
1152 #define DPROV_CKA_VALUE_LEN 0x00000161
1153 #define DPROV_CKA_EXTRACTABLE 0x00000162
1154 #define DPROV_CKA_EC_PARAMS 0x00000180
1155 #define DPROV_CKA_EC_POINT 0x00000181
1156 #define DPROV_HW_FEATURE_TYPE 0x00000300
1157
1158 /*
1159 * Object classes from PKCS#11
1160 */
1161 #define DPROV_CKO_DATA 0x00000000
1162 #define DPROV_CKO_CERTIFICATE 0x00000001
1163 #define DPROV_CKO_PUBLIC_KEY 0x00000002
1164 #define DPROV_CKO_PRIVATE_KEY 0x00000003
1165 #define DPROV_CKO_SECRET_KEY 0x00000004
1166 #define DPROV_CKO_HW_FEATURE 0x00000005
1167 #define DPROV_CKO_DOMAIN_PARAMETERS 0x00000006
1168 #define DPROV_CKO_VENDOR_DEFINED 0x80000000
1169
1170 /*
1171 * A few key types from PKCS#11
1172 */
1173 #define DPROV_CKK_RSA 0x00000000
1174 #define DPROV_CKK_GENERIC_SECRET 0x00000010
1175 #define DPROV_CKK_RC4 0x00000012
1176 #define DPROV_CKK_DES 0x00000013
1177 #define DPROV_CKK_DES3 0x00000015
1178 #define DPROV_CKK_AES 0x0000001F
1179 #define DPROV_CKK_BLOWFISH 0x00000020
1180
1181 /*
1182 * Find object context. Allows the find object init/find/final
1183 * to store data persistent across calls.
1184 */
1185 typedef struct dprov_find_ctx {
1186 crypto_object_id_t fc_ids[DPROV_MAX_OBJECTS]; /* object ids */
1187 uint_t fc_nids; /* number of ids in fc_ids */
1188 uint_t fc_next; /* next id to return */
1189 } dprov_find_ctx_t;
1190
1191 /*
1192 * Session management: each instance is associated with an array
1193 * of sessions. KEF providers sessions are always R/W the library and
1194 * the ioctl maintain the PKCS#11 R/W attributes for the session.
1195 */
1196
1197 #define DPROV_MIN_SESSIONS 32 /* # of sessions to start with */
1198
1199 typedef enum dprov_session_state {
1200 DPROV_SESSION_STATE_PUBLIC, /* public (default) */
1201 DPROV_SESSION_STATE_SO, /* SO logged in */
1202 DPROV_SESSION_STATE_USER /* user logged in */
1203 } dprov_session_state_t;
1204
1205 /* session description */
1206 typedef struct dprov_session {
1207 dprov_session_state_t ds_state; /* session state */
1208 dprov_object_t *ds_objects[DPROV_MAX_OBJECTS]; /* session objects */
1209 } dprov_session_t;
1210
1211
1212 static crypto_provider_info_t dprov_prov_info = {
1213 CRYPTO_SPI_VERSION_2,
1214 "Dummy Pseudo HW Provider",
1215 CRYPTO_HW_PROVIDER,
1216 NULL, /* pi_provider_dev */
1217 NULL, /* pi_provider_handle */
1218 &dprov_crypto_ops,
1219 sizeof (dprov_mech_info_tab)/sizeof (crypto_mech_info_t),
1220 dprov_mech_info_tab,
1221 0, /* pi_logical_provider_count */
1222 NULL, /* pi_logical_providers */
1223 0 /* pi_flags */
1224 };
1225
1226 /*
1227 * Per-instance info.
1228 */
1229 typedef struct dprov_state {
1230 kmutex_t ds_lock; /* per-instance lock */
1231 dev_info_t *ds_dip; /* device info */
1232 crypto_kcf_provider_handle_t ds_prov_handle; /* framework handle */
1233 taskq_t *ds_taskq; /* taskq for async behavior */
1234 char ds_user_pin[DPROV_MAX_PIN_LEN]; /* normal user PIN */
1235 uint_t ds_user_pin_len;
1236 char ds_so_pin[DPROV_MAX_PIN_LEN]; /* SO PIN */
1237 uint_t ds_so_pin_len;
1238 dprov_session_t **ds_sessions; /* sessions for this instance */
1239 uint_t ds_sessions_slots; /* number of session slots */
1240 uint_t ds_sessions_count; /* number of open sessions */
1241 boolean_t ds_token_initialized; /* provider initialized? */
1242 boolean_t ds_user_pin_set; /* user pin set? */
1243 char ds_label[CRYPTO_EXT_SIZE_LABEL]; /* "token" label */
1244 dprov_object_t *ds_objects[DPROV_MAX_OBJECTS]; /* "token" objects */
1245 } dprov_state_t;
1246
1247
1248 /*
1249 * A taskq is associated with each instance of the pseudo driver in order
1250 * to simulate the asynchronous execution of requests.
1251 * The following defines the taskq request structures.
1252 */
1253
1254 /* request types */
1255 typedef enum dprov_req_type {
1256 /* digest requests */
1257 DPROV_REQ_DIGEST_INIT = 1,
1258 DPROV_REQ_DIGEST,
1259 DPROV_REQ_DIGEST_UPDATE,
1260 DPROV_REQ_DIGEST_KEY,
1261 DPROV_REQ_DIGEST_FINAL,
1262 DPROV_REQ_DIGEST_ATOMIC,
1263 /* cipher requests */
1264 DPROV_REQ_ENCRYPT_INIT,
1265 DPROV_REQ_ENCRYPT,
1266 DPROV_REQ_ENCRYPT_UPDATE,
1267 DPROV_REQ_ENCRYPT_FINAL,
1268 DPROV_REQ_ENCRYPT_ATOMIC,
1269 DPROV_REQ_DECRYPT_INIT,
1270 DPROV_REQ_DECRYPT,
1271 DPROV_REQ_DECRYPT_UPDATE,
1272 DPROV_REQ_DECRYPT_FINAL,
1273 DPROV_REQ_DECRYPT_ATOMIC,
1274 /* mac requests */
1275 DPROV_REQ_MAC_INIT,
1276 DPROV_REQ_MAC,
1277 DPROV_REQ_MAC_UPDATE,
1278 DPROV_REQ_MAC_FINAL,
1279 DPROV_REQ_MAC_ATOMIC,
1280 DPROV_REQ_MAC_VERIFY_ATOMIC,
1281 /* sign requests */
1282 DPROV_REQ_SIGN_INIT,
1283 DPROV_REQ_SIGN,
1284 DPROV_REQ_SIGN_UPDATE,
1285 DPROV_REQ_SIGN_FINAL,
1286 DPROV_REQ_SIGN_ATOMIC,
1287 DPROV_REQ_SIGN_RECOVER_INIT,
1288 DPROV_REQ_SIGN_RECOVER,
1289 DPROV_REQ_SIGN_RECOVER_ATOMIC,
1290 /* verify requests */
1291 DPROV_REQ_VERIFY_INIT,
1292 DPROV_REQ_VERIFY,
1293 DPROV_REQ_VERIFY_UPDATE,
1294 DPROV_REQ_VERIFY_FINAL,
1295 DPROV_REQ_VERIFY_ATOMIC,
1296 DPROV_REQ_VERIFY_RECOVER_INIT,
1297 DPROV_REQ_VERIFY_RECOVER,
1298 DPROV_REQ_VERIFY_RECOVER_ATOMIC,
1299 /* dual ops requests */
1300 DPROV_REQ_DIGEST_ENCRYPT_UPDATE,
1301 DPROV_REQ_DECRYPT_DIGEST_UPDATE,
1302 DPROV_REQ_SIGN_ENCRYPT_UPDATE,
1303 DPROV_REQ_DECRYPT_VERIFY_UPDATE,
1304 /* dual cipher/mac requests */
1305 DPROV_REQ_ENCRYPT_MAC_INIT,
1306 DPROV_REQ_ENCRYPT_MAC,
1307 DPROV_REQ_ENCRYPT_MAC_UPDATE,
1308 DPROV_REQ_ENCRYPT_MAC_FINAL,
1309 DPROV_REQ_ENCRYPT_MAC_ATOMIC,
1310 DPROV_REQ_MAC_DECRYPT_INIT,
1311 DPROV_REQ_MAC_DECRYPT,
1312 DPROV_REQ_MAC_DECRYPT_UPDATE,
1313 DPROV_REQ_MAC_DECRYPT_FINAL,
1314 DPROV_REQ_MAC_DECRYPT_ATOMIC,
1315 DPROV_REQ_MAC_VERIFY_DECRYPT_ATOMIC,
1316 /* random number ops */
1317 DPROV_REQ_RANDOM_SEED,
1318 DPROV_REQ_RANDOM_GENERATE,
1319 /* session management requests */
1320 DPROV_REQ_SESSION_OPEN,
1321 DPROV_REQ_SESSION_CLOSE,
1322 DPROV_REQ_SESSION_LOGIN,
1323 DPROV_REQ_SESSION_LOGOUT,
1324 /* object management requests */
1325 DPROV_REQ_OBJECT_CREATE,
1326 DPROV_REQ_OBJECT_COPY,
1327 DPROV_REQ_OBJECT_DESTROY,
1328 DPROV_REQ_OBJECT_GET_SIZE,
1329 DPROV_REQ_OBJECT_GET_ATTRIBUTE_VALUE,
1330 DPROV_REQ_OBJECT_SET_ATTRIBUTE_VALUE,
1331 DPROV_REQ_OBJECT_FIND_INIT,
1332 DPROV_REQ_OBJECT_FIND,
1333 DPROV_REQ_OBJECT_FIND_FINAL,
1334 /* key management requests */
1335 DPROV_REQ_KEY_GENERATE,
1336 DPROV_REQ_KEY_GENERATE_PAIR,
1337 DPROV_REQ_KEY_WRAP,
1338 DPROV_REQ_KEY_UNWRAP,
1339 DPROV_REQ_KEY_DERIVE,
1340 /* provider management requests */
1341 DPROV_REQ_MGMT_EXTINFO,
1342 DPROV_REQ_MGMT_INITTOKEN,
1343 DPROV_REQ_MGMT_INITPIN,
1344 DPROV_REQ_MGMT_SETPIN,
1345 /* no (key)store key management requests */
1346 DPROV_REQ_NOSTORE_KEY_GENERATE,
1347 DPROV_REQ_NOSTORE_KEY_GENERATE_PAIR,
1348 DPROV_REQ_NOSTORE_KEY_DERIVE
1349 } dprov_req_type_t;
1350
1351 /* for DPROV_REQ_DIGEST requests */
1352 typedef struct dprov_digest_req {
1353 crypto_mechanism_t *dr_mechanism;
1354 crypto_ctx_t *dr_ctx;
1355 crypto_data_t *dr_data;
1356 crypto_key_t *dr_key;
1357 crypto_data_t *dr_digest;
1358 } dprov_digest_req_t;
1359
1360 /* for DPROV_REQ_MAC requests */
1361 typedef struct dprov_mac_req {
1362 crypto_mechanism_t *dr_mechanism;
1363 crypto_ctx_t *dr_ctx;
1364 crypto_key_t *dr_key;
1365 crypto_data_t *dr_data;
1366 crypto_data_t *dr_mac;
1367 crypto_session_id_t dr_session_id;
1368 } dprov_mac_req_t;
1369
1370 /* for DPROV_REQ_ENCRYPT and DPROV_REQ_DECRYPT requests */
1371 typedef struct dprov_cipher_req {
1372 crypto_mechanism_t *dr_mechanism;
1373 crypto_ctx_t *dr_ctx;
1374 crypto_key_t *dr_key;
1375 crypto_data_t *dr_plaintext;
1376 crypto_data_t *dr_ciphertext;
1377 crypto_session_id_t dr_session_id;
1378 } dprov_cipher_req_t;
1379
1380 /* for DPROV_REQ_SIGN requests */
1381 typedef struct dprov_sign_req {
1382 crypto_mechanism_t *sr_mechanism;
1383 crypto_ctx_t *sr_ctx;
1384 crypto_key_t *sr_key;
1385 crypto_data_t *sr_data;
1386 crypto_data_t *sr_signature;
1387 crypto_session_id_t sr_session_id;
1388 } dprov_sign_req_t;
1389
1390 /* for DPROV_REQ_VERIFY requests */
1391 typedef struct dprov_verify_req {
1392 crypto_mechanism_t *vr_mechanism;
1393 crypto_ctx_t *vr_ctx;
1394 crypto_key_t *vr_key;
1395 crypto_data_t *vr_data;
1396 crypto_data_t *vr_signature;
1397 crypto_session_id_t vr_session_id;
1398 } dprov_verify_req_t;
1399
1400 /* for dual ops requests */
1401 typedef struct dprov_dual_req {
1402 crypto_ctx_t *dr_signverify_ctx;
1403 crypto_ctx_t *dr_cipher_ctx;
1404 crypto_data_t *dr_plaintext;
1405 crypto_data_t *dr_ciphertext;
1406 } dprov_dual_req_t;
1407
1408 /* for cipher/mac dual ops requests */
1409 typedef struct dprov_cipher_mac_req {
1410 crypto_session_id_t mr_session_id;
1411 crypto_ctx_t *mr_ctx;
1412 crypto_mechanism_t *mr_cipher_mech;
1413 crypto_key_t *mr_cipher_key;
1414 crypto_mechanism_t *mr_mac_mech;
1415 crypto_key_t *mr_mac_key;
1416 crypto_dual_data_t *mr_dual_data;
1417 crypto_data_t *mr_data;
1418 crypto_data_t *mr_mac;
1419 } dprov_cipher_mac_req_t;
1420
1421 /* for DPROV_REQ_RANDOM requests */
1422 typedef struct dprov_random_req {
1423 uchar_t *rr_buf;
1424 size_t rr_len;
1425 crypto_session_id_t rr_session_id;
1426 uint_t rr_entropy_est;
1427 uint32_t rr_flags;
1428 } dprov_random_req_t;
1429
1430 /* for DPROV_REQ_SESSION requests */
1431 typedef struct dprov_session_req {
1432 crypto_session_id_t *sr_session_id_ptr;
1433 crypto_session_id_t sr_session_id;
1434 crypto_user_type_t sr_user_type;
1435 char *sr_pin;
1436 size_t sr_pin_len;
1437 } dprov_session_req_t;
1438
1439 /* for DPROV_REQ_OBJECT requests */
1440 typedef struct dprov_object_req {
1441 crypto_session_id_t or_session_id;
1442 crypto_object_id_t or_object_id;
1443 crypto_object_attribute_t *or_template;
1444 uint_t or_attribute_count;
1445 crypto_object_id_t *or_object_id_ptr;
1446 size_t *or_object_size;
1447 void **or_find_pp;
1448 void *or_find_p;
1449 uint_t or_max_object_count;
1450 uint_t *or_object_count_ptr;
1451 } dprov_object_req_t;
1452
1453 /* for DPROV_REQ_KEY requests */
1454 typedef struct dprov_key_req {
1455 crypto_session_id_t kr_session_id;
1456 crypto_mechanism_t *kr_mechanism;
1457 crypto_object_attribute_t *kr_template;
1458 uint_t kr_attribute_count;
1459 crypto_object_id_t *kr_object_id_ptr;
1460 crypto_object_attribute_t *kr_private_key_template;
1461 uint_t kr_private_key_attribute_count;
1462 crypto_object_id_t *kr_private_key_object_id_ptr;
1463 crypto_key_t *kr_key;
1464 uchar_t *kr_wrapped_key;
1465 size_t *kr_wrapped_key_len_ptr;
1466 crypto_object_attribute_t *kr_out_template1;
1467 crypto_object_attribute_t *kr_out_template2;
1468 uint_t kr_out_attribute_count1;
1469 uint_t kr_out_attribute_count2;
1470 } dprov_key_req_t;
1471
1472 /* for DPROV_REQ_MGMT requests */
1473 typedef struct dprov_mgmt_req {
1474 crypto_session_id_t mr_session_id;
1475 char *mr_pin;
1476 size_t mr_pin_len;
1477 char *mr_old_pin;
1478 size_t mr_old_pin_len;
1479 char *mr_label;
1480 crypto_provider_ext_info_t *mr_ext_info;
1481 } dprov_mgmt_req_t;
1482
1483 /* request, as queued on taskq */
1484 typedef struct dprov_req {
1485 dprov_req_type_t dr_type;
1486 dprov_state_t *dr_softc;
1487 crypto_req_handle_t dr_kcf_req;
1488 union {
1489 dprov_digest_req_t dru_digest_req;
1490 dprov_mac_req_t dru_mac_req;
1491 dprov_cipher_req_t dru_cipher_req;
1492 dprov_sign_req_t dru_sign_req;
1493 dprov_verify_req_t dru_verify_req;
1494 dprov_dual_req_t dru_dual_req;
1495 dprov_cipher_mac_req_t dru_cipher_mac_req;
1496 dprov_random_req_t dru_random_req;
1497 dprov_session_req_t dru_session_req;
1498 dprov_object_req_t dru_object_req;
1499 dprov_key_req_t dru_key_req;
1500 dprov_mgmt_req_t dru_mgmt_req;
1501 } dr_req;
1502 } dprov_req_t;
1503
1504 /* shortcuts for union fields */
1505 #define dr_digest_req dr_req.dru_digest_req
1506 #define dr_mac_req dr_req.dru_mac_req
1507 #define dr_cipher_req dr_req.dru_cipher_req
1508 #define dr_sign_req dr_req.dru_sign_req
1509 #define dr_verify_req dr_req.dru_verify_req
1510 #define dr_dual_req dr_req.dru_dual_req
1511 #define dr_cipher_mac_req dr_req.dru_cipher_mac_req
1512 #define dr_random_req dr_req.dru_random_req
1513 #define dr_session_req dr_req.dru_session_req
1514 #define dr_object_req dr_req.dru_object_req
1515 #define dr_key_req dr_req.dru_key_req
1516 #define dr_mgmt_req dr_req.dru_mgmt_req
1517
1518 /* prototypes for the tasq dispatcher functions */
1519 static void dprov_digest_task(dprov_req_t *);
1520 static void dprov_mac_task(dprov_req_t *);
1521 static void dprov_sign_task(dprov_req_t *);
1522 static void dprov_verify_task(dprov_req_t *);
1523 static void dprov_dual_task(dprov_req_t *);
1524 static void dprov_cipher_task(dprov_req_t *);
1525 static void dprov_cipher_mac_task(dprov_req_t *);
1526 static void dprov_random_task(dprov_req_t *);
1527 static void dprov_session_task(dprov_req_t *);
1528 static void dprov_object_task(dprov_req_t *);
1529 static void dprov_key_task(dprov_req_t *);
1530 static void dprov_mgmt_task(dprov_req_t *);
1531
1532 /* helper functions */
1533 static int dprov_digest_submit_req(dprov_req_type_t, dprov_state_t *,
1534 crypto_req_handle_t, crypto_mechanism_t *, crypto_data_t *, crypto_key_t *,
1535 crypto_data_t *, crypto_ctx_t *, int);
1536 static int dprov_cipher_submit_req(dprov_req_type_t, dprov_state_t *,
1537 crypto_req_handle_t, crypto_mechanism_t *, crypto_key_t *, crypto_data_t *,
1538 crypto_data_t *, crypto_ctx_t *, crypto_session_id_t, int);
1539 static int dprov_mac_submit_req(dprov_req_type_t, dprov_state_t *,
1540 crypto_req_handle_t, crypto_mechanism_t *, crypto_data_t *,
1541 crypto_key_t *, crypto_data_t *, crypto_ctx_t *, crypto_session_id_t, int);
1542 static int dprov_sign_submit_req(dprov_req_type_t, dprov_state_t *,
1543 crypto_req_handle_t, crypto_mechanism_t *, crypto_key_t *,
1544 crypto_data_t *, crypto_data_t *, crypto_ctx_t *, crypto_session_id_t, int);
1545 static int dprov_verify_submit_req(dprov_req_type_t, dprov_state_t *,
1546 crypto_req_handle_t, crypto_mechanism_t *, crypto_key_t *,
1547 crypto_data_t *, crypto_data_t *, crypto_ctx_t *, crypto_session_id_t, int);
1548 static int dprov_dual_submit_req(dprov_req_type_t, dprov_state_t *,
1549 crypto_req_handle_t, crypto_ctx_t *, crypto_ctx_t *, crypto_data_t *,
1550 crypto_data_t *);
1551 static int dprov_cipher_mac_submit_req(dprov_req_type_t, dprov_state_t *,
1552 crypto_req_handle_t, crypto_ctx_t *, crypto_session_id_t,
1553 crypto_mechanism_t *, crypto_key_t *, crypto_mechanism_t *, crypto_key_t *,
1554 crypto_dual_data_t *, crypto_data_t *, crypto_data_t *, int);
1555 static int dprov_random_submit_req(dprov_req_type_t, dprov_state_t *,
1556 crypto_req_handle_t, uchar_t *, size_t, crypto_session_id_t, uint_t,
1557 uint32_t);
1558 static int dprov_session_submit_req(dprov_req_type_t, dprov_state_t *,
1559 crypto_req_handle_t, crypto_session_id_t *, crypto_session_id_t,
1560 crypto_user_type_t, char *, size_t);
1561 static int dprov_object_submit_req(dprov_req_type_t, dprov_state_t *,
1562 crypto_req_handle_t, crypto_session_id_t, crypto_object_id_t,
1563 crypto_object_attribute_t *, uint_t, crypto_object_id_t *, size_t *,
1564 void **, void *, uint_t, uint_t *, int);
1565 static int dprov_key_submit_req(dprov_req_type_t, dprov_state_t *,
1566 crypto_req_handle_t, crypto_session_id_t, crypto_mechanism_t *,
1567 crypto_object_attribute_t *, uint_t, crypto_object_id_t *,
1568 crypto_object_attribute_t *, uint_t, crypto_object_id_t *,
1569 crypto_key_t *, uchar_t *, size_t *, crypto_object_attribute_t *,
1570 uint_t, crypto_object_attribute_t *, uint_t);
1571 static int dprov_mgmt_submit_req(dprov_req_type_t, dprov_state_t *,
1572 crypto_req_handle_t, crypto_session_id_t, char *, size_t, char *, size_t,
1573 char *, crypto_provider_ext_info_t *);
1574 static int dprov_get_sw_prov(crypto_mechanism_t *, kcf_provider_desc_t **,
1575 crypto_mech_type_t *);
1576
1577 /* object management helper functions */
1578 static void dprov_free_object(dprov_object_t *);
1579 static void dprov_release_session_objects(dprov_session_t *);
1580 static void dprov_adjust_attrs(crypto_object_attribute_t *, int);
1581 static boolean_t dprov_object_is_private(dprov_object_t *);
1582 static boolean_t dprov_object_is_token(dprov_object_t *);
1583 static int dprov_key_value_secret(dprov_state_t *, crypto_session_id_t,
1584 dprov_req_type_t, crypto_key_t *, crypto_key_t *);
1585 static int dprov_key_attr_asymmetric(dprov_state_t *, crypto_session_id_t,
1586 dprov_req_type_t, crypto_key_t *, crypto_key_t *);
1587 static int dprov_get_object_attr_boolean(dprov_object_t *, uint64_t,
1588 boolean_t *);
1589 static int dprov_get_object_attr_ulong(dprov_object_t *, uint64_t, ulong_t *);
1590 static int dprov_get_object_attr_array(dprov_object_t *, uint64_t, void **,
1591 size_t *);
1592 static int dprov_get_key_attr_ulong(crypto_key_t *, uint64_t, ulong_t *);
1593 static int dprov_get_key_attr_array(crypto_key_t *, uint64_t, void **,
1594 size_t *);
1595 static int dprov_create_object_from_template(dprov_state_t *, dprov_session_t *,
1596 crypto_object_attribute_t *, uint_t, crypto_object_id_t *, boolean_t,
1597 boolean_t);
1598 static int dprov_get_template_attr_scalar_common(crypto_object_attribute_t *,
1599 uint_t, uint64_t, void *, size_t);
1600 static int dprov_get_template_attr_boolean(crypto_object_attribute_t *,
1601 uint_t, uint64_t, boolean_t *);
1602 static int dprov_get_template_attr_ulong(crypto_object_attribute_t *, uint_t,
1603 uint64_t, ulong_t *);
1604 static int dprov_template_attr_present(crypto_object_attribute_t *, uint_t,
1605 uint64_t);
1606 static int dprov_get_template_attr_array(crypto_object_attribute_t *, uint_t,
1607 uint64_t, void **, size_t *);
1608 static int dprov_destroy_object(dprov_state_t *, dprov_session_t *,
1609 crypto_object_id_t);
1610 static int dprov_object_set_attr(dprov_session_t *, crypto_object_id_t,
1611 crypto_object_attribute_t *, uint_t, boolean_t);
1612 static int dprov_find_attr(crypto_object_attribute_t *, uint_t, uint64_t);
1613 static boolean_t dprov_attributes_match(dprov_object_t *,
1614 crypto_object_attribute_t *, uint_t);
1615
1616 /* retrieve the softc and instance number from a SPI crypto context */
1617 #define DPROV_SOFTC_FROM_CTX(ctx, softc, instance) { \
1618 (softc) = (dprov_state_t *)(ctx)->cc_provider; \
1619 (instance) = ddi_get_instance((softc)->ds_dip); \
1620 }
1621
1622 /* retrieve the softc and instance number from a taskq request */
1623 #define DPROV_SOFTC_FROM_REQ(req, softc, instance) { \
1624 (softc) = (req)->dr_softc; \
1625 (instance) = ddi_get_instance((softc)->ds_dip); \
1626 }
1627
1628 /*
1629 * The dprov private context most of the time contains a pointer to the
1630 * crypto_context_t that was allocated when calling a KCF function.
1631 * Dual cipher/mac operations however require the dprov driver
1632 * to maintain the contexts associated with the separate cipher
1633 * and mac operations. These two types of dprov contexts are
1634 * defined below.
1635 */
1636 typedef enum dprov_ctx_type {
1637 DPROV_CTX_SINGLE,
1638 DPROV_CTX_DUAL
1639 } dprov_ctx_type_t;
1640
1641 /*
1642 * When the context refers to a single KCF context, the
1643 * cc_provider field of a crypto_ctx_t points to a structure of
1644 * type dprov_ctx_single.
1645 */
1646 typedef struct dprov_ctx_single {
1647 dprov_ctx_type_t dc_type;
1648 crypto_context_t dc_ctx;
1649 boolean_t dc_svrfy_to_mac;
1650 } dprov_ctx_single_t;
1651
1652 /*
1653 * When the context is used for cipher/mac operations, it contains
1654 * pointers to to KCF contexts, one for the cipher operation, the
1655 * other for the mac operation.
1656 */
1657 typedef struct dprov_ctx_dual {
1658 dprov_ctx_type_t cd_type;
1659 crypto_context_t cd_cipher_ctx;
1660 crypto_context_t cd_mac_ctx;
1661 } dprov_ctx_dual_t;
1662
1663 /*
1664 * Helper macros for context accessors. These macros return the
1665 * k-API context corresponding to the given SPI context for
1666 * single and dual cipher/mac operations.
1667 */
1668
1669 #define DPROV_CTX_P(_ctx) \
1670 ((dprov_ctx_single_t *)(_ctx)->cc_provider_private)
1671
1672 #define DPROV_CTX_SINGLE(_ctx) ((DPROV_CTX_P(_ctx))->dc_ctx)
1673
1674 #define DPROV_CTX_DUAL_CIPHER(_ctx) \
1675 (((dprov_ctx_dual_t *)(_ctx)->cc_provider_private)->cd_cipher_ctx)
1676
1677 #define DPROV_CTX_DUAL_MAC(_ctx) \
1678 (((dprov_ctx_dual_t *)(_ctx)->cc_provider_private)->cd_mac_ctx)
1679
1680 static int dprov_alloc_context(dprov_req_type_t, crypto_ctx_t *);
1681
1682
1683
1684 static void *statep; /* state pointer */
1685
1686 /*
1687 * DDI entry points.
1688 */
1689 int
1690 _init(void)
1691 {
1692 int error;
1693
1694 DPROV_DEBUG(D_INIT, ("dprov: in _init\n"));
1695
1696 if ((error = ddi_soft_state_init(&statep, sizeof (dprov_state_t),
1697 0)) != 0)
1698 return (error);
1699
1700 return (mod_install(&modlinkage));
1701 }
1702
1703 int
1704 _fini(void)
1705 {
1706 int error;
1707
1708 DPROV_DEBUG(D_INIT, ("dprov: in _fini\n"));
1709
1710 if ((error = mod_remove(&modlinkage)) != 0)
1711 return (error);
1712
1713 ddi_soft_state_fini(&statep);
1714
1715 return (0);
1716 }
1717
1718 int
1719 _info(struct modinfo *modinfop)
1720 {
1721 DPROV_DEBUG(D_INIT, ("dprov: in _info\n"));
1722
1723 return (mod_info(&modlinkage, modinfop));
1724 }
1725
1726 /* ARGSUSED */
1727 static int
1728 dprov_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
1729 {
1730 int instance = getminor((dev_t)arg);
1731 dprov_state_t *softc;
1732
1733 DPROV_DEBUG(D_ATTACH, ("dprov: in dprov_getinfo() for %d\n",
1734 instance));
1735
1736 switch (cmd) {
1737 case DDI_INFO_DEVT2DEVINFO:
1738 softc = ddi_get_soft_state(statep, instance);
1739 *result = softc->ds_dip;
1740 return (DDI_SUCCESS);
1741
1742 case DDI_INFO_DEVT2INSTANCE:
1743 *result = (void *)(uintptr_t)instance;
1744 return (DDI_SUCCESS);
1745 }
1746 return (DDI_FAILURE);
1747 }
1748
1749 static int
1750 dprov_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
1751 {
1752 int instance = ddi_get_instance(dip);
1753 dprov_state_t *softc;
1754 char devname[256];
1755 int ret;
1756
1757 DPROV_DEBUG(D_ATTACH, ("dprov: in dprov_attach() for %d\n",
1758 instance));
1759
1760 if (cmd != DDI_ATTACH) {
1761 return (DDI_FAILURE);
1762 }
1763
1764 /* get new softc and initialize it */
1765 if (ddi_soft_state_zalloc(statep, instance) != DDI_SUCCESS)
1766 return (DDI_FAILURE);
1767
1768 softc = ddi_get_soft_state(statep, instance);
1769 mutex_init(&softc->ds_lock, NULL, MUTEX_DRIVER, NULL);
1770 softc->ds_dip = dip;
1771 softc->ds_prov_handle = NULL;
1772
1773 /* create minor node */
1774 (void) sprintf(devname, "dprov%d", instance);
1775 if (ddi_create_minor_node(dip, devname, S_IFCHR, instance,
1776 DDI_PSEUDO, 0) != DDI_SUCCESS) {
1777 cmn_err(CE_WARN, "attach: failed creating minor node");
1778 mutex_destroy(&softc->ds_lock);
1779 ddi_soft_state_free(statep, instance);
1780 return (DDI_FAILURE);
1781 }
1782
1783 nostore_key_gen = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1784 DDI_PROP_DONTPASS, "nostore_key_gen", 0);
1785 if (nostore_key_gen != 0) {
1786 dprov_prov_info.pi_interface_version = CRYPTO_SPI_VERSION_3;
1787 dprov_crypto_ops.co_object_ops = NULL;
1788 dprov_crypto_ops.co_nostore_key_ops = &dprov_nostore_key_ops;
1789 }
1790
1791 dprov_max_digestsz = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1792 DDI_PROP_DONTPASS, "max_digest_sz", INT_MAX);
1793 if (dprov_max_digestsz != INT_MAX && dprov_max_digestsz != 0 &&
1794 dprov_max_digestsz != DDI_PROP_NOT_FOUND) {
1795 dprov_no_multipart = B_TRUE;
1796 dprov_prov_info.pi_flags |=
1797 (CRYPTO_HASH_NO_UPDATE | CRYPTO_HMAC_NO_UPDATE);
1798 }
1799
1800 /* create taskq */
1801 softc->ds_taskq = taskq_create(devname, 1, minclsyspri,
1802 crypto_taskq_minalloc, crypto_taskq_maxalloc, TASKQ_PREPOPULATE);
1803
1804 /* initialize table of sessions */
1805 softc->ds_sessions = kmem_zalloc(DPROV_MIN_SESSIONS *
1806 sizeof (dprov_session_t *), KM_SLEEP);
1807 softc->ds_sessions_slots = DPROV_MIN_SESSIONS;
1808 softc->ds_sessions_count = 0;
1809
1810 /* initialized done by init_token entry point */
1811 softc->ds_token_initialized = B_TRUE;
1812
1813 (void) memset(softc->ds_label, ' ', CRYPTO_EXT_SIZE_LABEL);
1814 bcopy("Dummy Pseudo HW Provider", softc->ds_label, 24);
1815
1816 bcopy("changeme", softc->ds_user_pin, 8);
1817 softc->ds_user_pin_len = 8;
1818 softc->ds_user_pin_set = B_TRUE;
1819
1820 /* register with the crypto framework */
1821 dprov_prov_info.pi_provider_dev.pd_hw = dip;
1822 dprov_prov_info.pi_provider_handle = softc;
1823
1824 if (dprov_no_multipart) { /* Export only single part */
1825 dprov_digest_ops.digest_update = NULL;
1826 dprov_digest_ops.digest_key = NULL;
1827 dprov_digest_ops.digest_final = NULL;
1828 dprov_object_ops.object_create = NULL;
1829 }
1830
1831 if ((ret = crypto_register_provider(&dprov_prov_info,
1832 &softc->ds_prov_handle)) != CRYPTO_SUCCESS) {
1833 cmn_err(CE_WARN,
1834 "dprov crypto_register_provider() failed (0x%x)", ret);
1835 taskq_destroy(softc->ds_taskq);
1836 kmem_free(softc->ds_sessions, softc->ds_sessions_slots *
1837 sizeof (dprov_session_t *));
1838 mutex_destroy(&softc->ds_lock);
1839 ddi_soft_state_free(statep, instance);
1840 ddi_remove_minor_node(dip, NULL);
1841 return (DDI_FAILURE);
1842 }
1843
1844 /*
1845 * This call is for testing only; it is not required by the SPI.
1846 */
1847 crypto_provider_notification(softc->ds_prov_handle,
1848 CRYPTO_PROVIDER_READY);
1849
1850 return (DDI_SUCCESS);
1851 }
1852
1853 static int
1854 dprov_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1855 {
1856 int instance = ddi_get_instance(dip);
1857 dprov_state_t *softc = ddi_get_soft_state(statep, instance);
1858 dprov_session_t *session;
1859 int i, ret;
1860
1861 DPROV_DEBUG(D_ATTACH, ("dprov: in dprov_detach() for %d\n",
1862 instance));
1863
1864 if (cmd != DDI_DETACH)
1865 return (DDI_FAILURE);
1866
1867 /* unregister from the crypto framework */
1868 if (softc->ds_prov_handle != NULL)
1869 if ((ret = crypto_unregister_provider(
1870 softc->ds_prov_handle)) != CRYPTO_SUCCESS) {
1871 cmn_err(CE_WARN, "dprov_detach: "
1872 "crypto_unregister_provider() "
1873 "failed (0x%x)", ret);
1874 return (DDI_FAILURE);
1875 }
1876
1877
1878 taskq_destroy(softc->ds_taskq);
1879
1880 for (i = 0; i < softc->ds_sessions_slots; i++) {
1881 if ((session = softc->ds_sessions[i]) == NULL)
1882 continue;
1883
1884 dprov_release_session_objects(session);
1885
1886 kmem_free(session, sizeof (dprov_session_t));
1887 softc->ds_sessions_count--;
1888
1889 }
1890
1891 kmem_free(softc->ds_sessions, softc->ds_sessions_slots *
1892 sizeof (dprov_session_t *));
1893 /* free token objects */
1894 for (i = 0; i < DPROV_MAX_OBJECTS; i++)
1895 if (softc->ds_objects[i] != NULL)
1896 dprov_free_object(softc->ds_objects[i]);
1897
1898 mutex_destroy(&softc->ds_lock);
1899 ddi_soft_state_free(statep, instance);
1900
1901 ddi_remove_minor_node(dip, NULL);
1902
1903 return (DDI_SUCCESS);
1904 }
1905
1906 /*
1907 * Control entry points.
1908 */
1909 static void
1910 dprov_provider_status(crypto_provider_handle_t provider, uint_t *status)
1911 {
1912 _NOTE(ARGUNUSED(provider))
1913
1914 *status = CRYPTO_PROVIDER_READY;
1915 }
1916
1917 /*
1918 * Digest entry points.
1919 */
1920
1921 static int
1922 dprov_digest_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
1923 crypto_req_handle_t req)
1924 {
1925 int error = CRYPTO_FAILED;
1926 dprov_state_t *softc;
1927 /* LINTED E_FUNC_SET_NOT_USED */
1928 int instance;
1929
1930 /* extract softc and instance number from context */
1931 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
1932 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_init: started\n", instance));
1933
1934 /* check mechanism */
1935 if (mechanism->cm_type != MD4_MECH_INFO_TYPE &&
1936 mechanism->cm_type != MD5_MECH_INFO_TYPE &&
1937 mechanism->cm_type != SHA1_MECH_INFO_TYPE &&
1938 mechanism->cm_type != SHA256_MECH_INFO_TYPE &&
1939 mechanism->cm_type != SHA384_MECH_INFO_TYPE &&
1940 mechanism->cm_type != SHA512_MECH_INFO_TYPE) {
1941 cmn_err(CE_WARN, "dprov_digest_init: unexpected mech type "
1942 "0x%llx\n", (unsigned long long)mechanism->cm_type);
1943 return (CRYPTO_MECHANISM_INVALID);
1944 }
1945
1946 /* submit request to the taskq */
1947 error = dprov_digest_submit_req(DPROV_REQ_DIGEST_INIT, softc, req,
1948 mechanism, NULL, NULL, NULL, ctx, KM_SLEEP);
1949
1950 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_init: done err = 0x%x\n",
1951 instance, error));
1952
1953 return (error);
1954 }
1955
1956 static int
1957 dprov_digest(crypto_ctx_t *ctx, crypto_data_t *data, crypto_data_t *digest,
1958 crypto_req_handle_t req)
1959 {
1960 int error = CRYPTO_FAILED;
1961 dprov_state_t *softc;
1962 /* LINTED E_FUNC_SET_NOT_USED */
1963 int instance;
1964
1965 if (dprov_no_multipart && data->cd_length > dprov_max_digestsz)
1966 return (CRYPTO_BUFFER_TOO_BIG);
1967
1968 /* extract softc and instance number from context */
1969 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
1970 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest: started\n", instance));
1971
1972 /* submit request to the taskq */
1973 error = dprov_digest_submit_req(DPROV_REQ_DIGEST, softc, req,
1974 NULL, data, NULL, digest, ctx, KM_NOSLEEP);
1975
1976 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest: done, err = 0x%x\n",
1977 instance, error));
1978
1979 return (error);
1980 }
1981
1982 static int
1983 dprov_digest_update(crypto_ctx_t *ctx, crypto_data_t *data,
1984 crypto_req_handle_t req)
1985 {
1986 int error = CRYPTO_FAILED;
1987 dprov_state_t *softc;
1988 /* LINTED E_FUNC_SET_NOT_USED */
1989 int instance;
1990
1991 /* extract softc and instance number from context */
1992 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
1993 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_update: started\n",
1994 instance));
1995
1996 /* submit request to the taskq */
1997 error = dprov_digest_submit_req(DPROV_REQ_DIGEST_UPDATE, softc,
1998 req, NULL, data, NULL, NULL, ctx, KM_NOSLEEP);
1999
2000 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_update: done err = 0x0%x\n",
2001 instance, error));
2002
2003 return (error);
2004 }
2005
2006 static int
2007 dprov_digest_key(crypto_ctx_t *ctx, crypto_key_t *key, crypto_req_handle_t req)
2008 {
2009 int error = CRYPTO_FAILED;
2010 dprov_state_t *softc;
2011 /* LINTED E_FUNC_SET_NOT_USED */
2012 int instance;
2013
2014 /* extract softc and instance number from context */
2015 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2016 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_key: started\n", instance));
2017
2018 /* submit request to the taskq */
2019 error = dprov_digest_submit_req(DPROV_REQ_DIGEST_KEY, softc, req, NULL,
2020 NULL, key, NULL, ctx, KM_NOSLEEP);
2021
2022 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_key: done err = 0x0%x\n",
2023 instance, error));
2024
2025 return (error);
2026 }
2027
2028 static int
2029 dprov_digest_final(crypto_ctx_t *ctx, crypto_data_t *digest,
2030 crypto_req_handle_t req)
2031 {
2032 int error = CRYPTO_FAILED;
2033 dprov_state_t *softc;
2034 /* LINTED E_FUNC_SET_NOT_USED */
2035 int instance;
2036
2037 /* extract softc and instance number from context */
2038 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2039 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_final: started\n", instance));
2040
2041 /* submit request to the taskq */
2042 error = dprov_digest_submit_req(DPROV_REQ_DIGEST_FINAL, softc, req,
2043 NULL, NULL, NULL, digest, ctx, KM_NOSLEEP);
2044
2045 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_final: done err = 0x0%x\n",
2046 instance, error));
2047
2048 return (error);
2049 }
2050
2051 /* ARGSUSED */
2052 static int
2053 dprov_digest_atomic(crypto_provider_handle_t provider,
2054 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
2055 crypto_data_t *data, crypto_data_t *digest,
2056 crypto_req_handle_t req)
2057 {
2058 int error = CRYPTO_FAILED;
2059 dprov_state_t *softc = (dprov_state_t *)provider;
2060 /* LINTED E_FUNC_SET_NOT_USED */
2061 int instance;
2062
2063 if (dprov_no_multipart && data->cd_length > dprov_max_digestsz)
2064 return (CRYPTO_BUFFER_TOO_BIG);
2065
2066 instance = ddi_get_instance(softc->ds_dip);
2067 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_atomic: started\n",
2068 instance));
2069
2070 /* check mechanism */
2071 if (mechanism->cm_type != MD4_MECH_INFO_TYPE &&
2072 mechanism->cm_type != MD5_MECH_INFO_TYPE &&
2073 mechanism->cm_type != SHA1_MECH_INFO_TYPE &&
2074 mechanism->cm_type != SHA256_MECH_INFO_TYPE &&
2075 mechanism->cm_type != SHA384_MECH_INFO_TYPE &&
2076 mechanism->cm_type != SHA512_MECH_INFO_TYPE) {
2077 cmn_err(CE_WARN, "dprov_digest_atomic: unexpected mech type "
2078 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2079 return (CRYPTO_MECHANISM_INVALID);
2080 }
2081
2082 /* submit request to the taskq */
2083 error = dprov_digest_submit_req(DPROV_REQ_DIGEST_ATOMIC, softc, req,
2084 mechanism, data, NULL, digest, NULL, KM_SLEEP);
2085
2086 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_atomic: done err = 0x0%x\n",
2087 instance, error));
2088
2089 return (error);
2090 }
2091
2092 /*
2093 * MAC entry points.
2094 */
2095
2096 /*
2097 * Checks whether the specified mech_type is supported by mac
2098 * entry points.
2099 */
2100 static boolean_t
2101 dprov_valid_mac_mech(crypto_mech_type_t mech_type)
2102 {
2103 return (mech_type == MD5_HMAC_MECH_INFO_TYPE ||
2104 mech_type == MD5_HMAC_GEN_MECH_INFO_TYPE ||
2105 mech_type == SHA1_HMAC_MECH_INFO_TYPE ||
2106 mech_type == SHA1_HMAC_GEN_MECH_INFO_TYPE ||
2107 mech_type == SHA256_HMAC_MECH_INFO_TYPE ||
2108 mech_type == SHA256_HMAC_GEN_MECH_INFO_TYPE ||
2109 mech_type == SHA384_HMAC_MECH_INFO_TYPE ||
2110 mech_type == SHA384_HMAC_GEN_MECH_INFO_TYPE ||
2111 mech_type == SHA512_HMAC_MECH_INFO_TYPE ||
2112 mech_type == SHA512_HMAC_GEN_MECH_INFO_TYPE ||
2113 mech_type == AES_GMAC_MECH_INFO_TYPE);
2114 }
2115
2116 static int
2117 dprov_mac_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
2118 crypto_key_t *key, crypto_spi_ctx_template_t ctx_template,
2119 crypto_req_handle_t req)
2120 {
2121 int error = CRYPTO_FAILED;
2122 dprov_state_t *softc;
2123 /* LINTED E_FUNC_SET_NOT_USED */
2124 int instance;
2125
2126 /* extract softc and instance number from context */
2127 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2128 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_init: started\n", instance));
2129
2130 /* check mechanism */
2131 if (!dprov_valid_mac_mech(mechanism->cm_type)) {
2132 cmn_err(CE_WARN, "dprov_mac_init: unexpected mech type "
2133 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2134 return (CRYPTO_MECHANISM_INVALID);
2135 }
2136
2137 if (ctx_template != NULL)
2138 return (CRYPTO_ARGUMENTS_BAD);
2139
2140 /* submit request to the taskq */
2141 error = dprov_mac_submit_req(DPROV_REQ_MAC_INIT, softc, req,
2142 mechanism, NULL, key, NULL, ctx, 0, KM_SLEEP);
2143
2144 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_init: done err = 0x%x\n",
2145 instance, error));
2146
2147 return (error);
2148 }
2149
2150 static int
2151 dprov_mac(crypto_ctx_t *ctx, crypto_data_t *data, crypto_data_t *mac,
2152 crypto_req_handle_t req)
2153 {
2154 int error = CRYPTO_FAILED;
2155 dprov_state_t *softc;
2156 /* LINTED E_FUNC_SET_NOT_USED */
2157 int instance;
2158
2159 /* extract softc and instance number from context */
2160 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2161 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac: started\n", instance));
2162
2163 /* submit request to the taskq */
2164 error = dprov_mac_submit_req(DPROV_REQ_MAC, softc, req,
2165 NULL, data, NULL, mac, ctx, 0, KM_NOSLEEP);
2166
2167 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac: done, err = 0x%x\n", instance,
2168 error));
2169
2170 return (error);
2171 }
2172
2173 static int
2174 dprov_mac_update(crypto_ctx_t *ctx, crypto_data_t *data,
2175 crypto_req_handle_t req)
2176 {
2177 int error = CRYPTO_FAILED;
2178 dprov_state_t *softc;
2179 /* LINTED E_FUNC_SET_NOT_USED */
2180 int instance;
2181
2182 /* extract softc and instance number from context */
2183 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2184 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_update: started\n", instance));
2185
2186 /* submit request to the taskq */
2187 error = dprov_mac_submit_req(DPROV_REQ_MAC_UPDATE, softc,
2188 req, NULL, data, NULL, NULL, ctx, 0, KM_NOSLEEP);
2189
2190 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_update: done err = 0x0%x\n",
2191 instance, error));
2192
2193 return (error);
2194 }
2195
2196 static int
2197 dprov_mac_final(crypto_ctx_t *ctx, crypto_data_t *mac, crypto_req_handle_t req)
2198 {
2199 int error = CRYPTO_FAILED;
2200 dprov_state_t *softc;
2201 /* LINTED E_FUNC_SET_NOT_USED */
2202 int instance;
2203
2204 /* extract softc and instance number from context */
2205 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2206 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_final: started\n", instance));
2207
2208 /* submit request to the taskq */
2209 error = dprov_mac_submit_req(DPROV_REQ_MAC_FINAL, softc, req,
2210 NULL, NULL, NULL, mac, ctx, 0, KM_NOSLEEP);
2211
2212 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_final: done err = 0x0%x\n",
2213 instance, error));
2214
2215 return (error);
2216 }
2217
2218 static int
2219 dprov_mac_atomic(crypto_provider_handle_t provider,
2220 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
2221 crypto_key_t *key, crypto_data_t *data, crypto_data_t *mac,
2222 crypto_spi_ctx_template_t ctx_template, crypto_req_handle_t req)
2223 {
2224 int error = CRYPTO_FAILED;
2225 dprov_state_t *softc = (dprov_state_t *)provider;
2226 /* LINTED E_FUNC_SET_NOT_USED */
2227 int instance;
2228
2229 instance = ddi_get_instance(softc->ds_dip);
2230 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_atomic: started\n", instance));
2231
2232 if (ctx_template != NULL)
2233 return (CRYPTO_ARGUMENTS_BAD);
2234
2235 /* check mechanism */
2236 if (!dprov_valid_mac_mech(mechanism->cm_type)) {
2237 cmn_err(CE_WARN, "dprov_mac_atomic: unexpected mech type "
2238 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2239 return (CRYPTO_MECHANISM_INVALID);
2240 }
2241
2242 /* submit request to the taskq */
2243 error = dprov_mac_submit_req(DPROV_REQ_MAC_ATOMIC, softc, req,
2244 mechanism, data, key, mac, NULL, session_id, KM_SLEEP);
2245
2246 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_atomic: done err = 0x0%x\n",
2247 instance, error));
2248
2249 return (error);
2250 }
2251
2252 static int
2253 dprov_mac_verify_atomic(crypto_provider_handle_t provider,
2254 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
2255 crypto_key_t *key, crypto_data_t *data, crypto_data_t *mac,
2256 crypto_spi_ctx_template_t ctx_template, crypto_req_handle_t req)
2257 {
2258 int error = CRYPTO_FAILED;
2259 dprov_state_t *softc = (dprov_state_t *)provider;
2260 /* LINTED E_FUNC_SET_NOT_USED */
2261 int instance;
2262
2263 instance = ddi_get_instance(softc->ds_dip);
2264 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_verify_atomic: started\n",
2265 instance));
2266
2267 if (ctx_template != NULL)
2268 return (CRYPTO_ARGUMENTS_BAD);
2269
2270 /* check mechanism */
2271 if (!dprov_valid_mac_mech(mechanism->cm_type)) {
2272 cmn_err(CE_WARN, "dprov_mac_verify_atomic: unexpected mech "
2273 "type 0x%llx\n", (unsigned long long)mechanism->cm_type);
2274 return (CRYPTO_MECHANISM_INVALID);
2275 }
2276
2277 /* submit request to the taskq */
2278 error = dprov_mac_submit_req(DPROV_REQ_MAC_VERIFY_ATOMIC, softc, req,
2279 mechanism, data, key, mac, NULL, session_id, KM_SLEEP);
2280
2281 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_verify_atomic: done err = 0x0%x\n",
2282 instance, error));
2283
2284 return (error);
2285 }
2286
2287 /*
2288 * Cipher (encrypt/decrypt) entry points.
2289 */
2290
2291 /*
2292 * Checks whether the specified mech_type is supported by cipher entry
2293 * points.
2294 */
2295 static boolean_t
2296 dprov_valid_cipher_mech(crypto_mech_type_t mech_type)
2297 {
2298 return (mech_type == DES_CBC_MECH_INFO_TYPE ||
2299 mech_type == DES3_CBC_MECH_INFO_TYPE ||
2300 mech_type == DES_ECB_MECH_INFO_TYPE ||
2301 mech_type == DES3_ECB_MECH_INFO_TYPE ||
2302 mech_type == BLOWFISH_CBC_MECH_INFO_TYPE ||
2303 mech_type == BLOWFISH_ECB_MECH_INFO_TYPE ||
2304 mech_type == AES_CBC_MECH_INFO_TYPE ||
2305 mech_type == AES_ECB_MECH_INFO_TYPE ||
2306 mech_type == AES_CTR_MECH_INFO_TYPE ||
2307 mech_type == AES_CCM_MECH_INFO_TYPE ||
2308 mech_type == AES_GCM_MECH_INFO_TYPE ||
2309 mech_type == AES_GMAC_MECH_INFO_TYPE ||
2310 mech_type == RC4_MECH_INFO_TYPE ||
2311 mech_type == RSA_PKCS_MECH_INFO_TYPE ||
2312 mech_type == RSA_X_509_MECH_INFO_TYPE ||
2313 mech_type == MD5_RSA_PKCS_MECH_INFO_TYPE ||
2314 mech_type == SHA1_RSA_PKCS_MECH_INFO_TYPE ||
2315 mech_type == SHA256_RSA_PKCS_MECH_INFO_TYPE ||
2316 mech_type == SHA384_RSA_PKCS_MECH_INFO_TYPE ||
2317 mech_type == SHA512_RSA_PKCS_MECH_INFO_TYPE);
2318 }
2319
2320 static boolean_t
2321 is_publickey_mech(crypto_mech_type_t mech_type)
2322 {
2323 return (mech_type == RSA_PKCS_MECH_INFO_TYPE ||
2324 mech_type == RSA_X_509_MECH_INFO_TYPE ||
2325 mech_type == MD5_RSA_PKCS_MECH_INFO_TYPE ||
2326 mech_type == SHA1_RSA_PKCS_MECH_INFO_TYPE ||
2327 mech_type == SHA256_RSA_PKCS_MECH_INFO_TYPE ||
2328 mech_type == SHA384_RSA_PKCS_MECH_INFO_TYPE ||
2329 mech_type == SHA512_RSA_PKCS_MECH_INFO_TYPE ||
2330 mech_type == ECDSA_SHA1_MECH_INFO_TYPE ||
2331 mech_type == ECDSA_MECH_INFO_TYPE);
2332 }
2333
2334
2335 /* ARGSUSED */
2336 static int
2337 dprov_encrypt_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
2338 crypto_key_t *key, crypto_spi_ctx_template_t ctx_template,
2339 crypto_req_handle_t req)
2340 {
2341 int error = CRYPTO_FAILED;
2342 dprov_state_t *softc;
2343 /* LINTED E_FUNC_SET_NOT_USED */
2344 int instance;
2345
2346 /* extract softc and instance number from context */
2347 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2348 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_encrypt_init: started\n",
2349 instance));
2350
2351 /* check mechanism */
2352 if (!dprov_valid_cipher_mech(mechanism->cm_type)) {
2353 cmn_err(CE_WARN, "dprov_encrypt_init: unexpected mech type "
2354 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2355 return (CRYPTO_MECHANISM_INVALID);
2356 }
2357
2358 /* submit request to the taskq */
2359 error = dprov_cipher_submit_req(DPROV_REQ_ENCRYPT_INIT, softc,
2360 req, mechanism, key, NULL, NULL, ctx, 0, KM_SLEEP);
2361
2362 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_encrypt_init: done err = 0x0%x\n",
2363 instance, error));
2364
2365 return (error);
2366 }
2367
2368 /* ARGSUSED */
2369 static int
2370 dprov_encrypt(crypto_ctx_t *ctx, crypto_data_t *plaintext,
2371 crypto_data_t *ciphertext, crypto_req_handle_t req)
2372 {
2373 int error = CRYPTO_FAILED;
2374 dprov_state_t *softc;
2375 /* LINTED E_FUNC_SET_NOT_USED */
2376 int instance;
2377
2378 /* extract softc and instance number from context */
2379 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2380 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_encrypt: started\n", instance));
2381
2382 /* submit request to the taskq */
2383 error = dprov_cipher_submit_req(DPROV_REQ_ENCRYPT, softc,
2384 req, NULL, NULL, plaintext, ciphertext, ctx, 0, KM_NOSLEEP);
2385
2386 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_encrypt: done err = 0x0%x\n",
2387 instance, error));
2388
2389 return (error);
2390 }
2391
2392 /* ARGSUSED */
2393 static int
2394 dprov_encrypt_update(crypto_ctx_t *ctx, crypto_data_t *plaintext,
2395 crypto_data_t *ciphertext, crypto_req_handle_t req)
2396 {
2397 int error = CRYPTO_FAILED;
2398 dprov_state_t *softc;
2399 /* LINTED E_FUNC_SET_NOT_USED */
2400 int instance;
2401
2402 /* extract softc and instance number from context */
2403 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2404 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_encrypt_update: started\n",
2405 instance));
2406
2407 /* submit request to the taskq */
2408 error = dprov_cipher_submit_req(DPROV_REQ_ENCRYPT_UPDATE, softc,
2409 req, NULL, NULL, plaintext, ciphertext, ctx, 0, KM_NOSLEEP);
2410
2411 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_encrypt_update: done err = 0x0%x\n",
2412 instance, error));
2413
2414 return (error);
2415 }
2416
2417 /* ARGSUSED */
2418 static int
2419 dprov_encrypt_final(crypto_ctx_t *ctx, crypto_data_t *ciphertext,
2420 crypto_req_handle_t req)
2421 {
2422 int error = CRYPTO_FAILED;
2423 dprov_state_t *softc;
2424 /* LINTED E_FUNC_SET_NOT_USED */
2425 int instance;
2426
2427 /* extract softc and instance number from context */
2428 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2429 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_encrypt_final: started\n",
2430 instance));
2431
2432 /* submit request to the taskq */
2433 error = dprov_cipher_submit_req(DPROV_REQ_ENCRYPT_FINAL, softc,
2434 req, NULL, NULL, NULL, ciphertext, ctx, 0, KM_NOSLEEP);
2435
2436 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_encrypt_final: done err = 0x0%x\n",
2437 instance, error));
2438
2439 return (error);
2440 }
2441
2442 static int
2443 dprov_encrypt_atomic(crypto_provider_handle_t provider,
2444 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
2445 crypto_key_t *key, crypto_data_t *plaintext, crypto_data_t *ciphertext,
2446 crypto_spi_ctx_template_t ctx_template, crypto_req_handle_t req)
2447 {
2448 int error = CRYPTO_FAILED;
2449 dprov_state_t *softc = (dprov_state_t *)provider;
2450 /* LINTED E_FUNC_SET_NOT_USED */
2451 int instance;
2452
2453 instance = ddi_get_instance(softc->ds_dip);
2454 DPROV_DEBUG(D_MAC, ("(%d) dprov_encrypt_atomic: started\n", instance));
2455
2456 if (ctx_template != NULL)
2457 return (CRYPTO_ARGUMENTS_BAD);
2458
2459 /* check mechanism */
2460 if (!dprov_valid_cipher_mech(mechanism->cm_type)) {
2461 cmn_err(CE_WARN, "dprov_encrypt_atomic: unexpected mech type "
2462 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2463 return (CRYPTO_MECHANISM_INVALID);
2464 }
2465
2466 error = dprov_cipher_submit_req(DPROV_REQ_ENCRYPT_ATOMIC, softc,
2467 req, mechanism, key, plaintext, ciphertext, NULL, session_id,
2468 KM_SLEEP);
2469
2470 DPROV_DEBUG(D_MAC, ("(%d) dprov_encrypt_atomic: done err = 0x0%x\n",
2471 instance, error));
2472
2473 return (error);
2474 }
2475
2476 /* ARGSUSED */
2477 static int
2478 dprov_decrypt_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
2479 crypto_key_t *key, crypto_spi_ctx_template_t ctx_template,
2480 crypto_req_handle_t req)
2481 {
2482 int error = CRYPTO_FAILED;
2483 dprov_state_t *softc;
2484 /* LINTED E_FUNC_SET_NOT_USED */
2485 int instance;
2486
2487 /* extract softc and instance number from context */
2488 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2489 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_decrypt_init: started\n",
2490 instance));
2491
2492 /* check mechanism */
2493 if (!dprov_valid_cipher_mech(mechanism->cm_type)) {
2494 cmn_err(CE_WARN, "dprov_decrypt_init: unexpected mech type "
2495 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2496 return (CRYPTO_MECHANISM_INVALID);
2497 }
2498
2499 /* submit request to the taskq */
2500 error = dprov_cipher_submit_req(DPROV_REQ_DECRYPT_INIT, softc,
2501 req, mechanism, key, NULL, NULL, ctx, 0, KM_SLEEP);
2502
2503 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_decrypt_init: done err = 0x0%x\n",
2504 instance, error));
2505
2506 return (error);
2507 }
2508
2509 /* ARGSUSED */
2510 static int
2511 dprov_decrypt(crypto_ctx_t *ctx, crypto_data_t *ciphertext,
2512 crypto_data_t *plaintext, crypto_req_handle_t req)
2513 {
2514 int error = CRYPTO_FAILED;
2515
2516 dprov_state_t *softc;
2517 /* LINTED E_FUNC_SET_NOT_USED */
2518 int instance;
2519
2520 /* extract softc and instance number from context */
2521 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2522 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_decrypt: started\n", instance));
2523
2524 /* submit request to the taskq */
2525 error = dprov_cipher_submit_req(DPROV_REQ_DECRYPT, softc,
2526 req, NULL, NULL, plaintext, ciphertext, ctx, 0, KM_NOSLEEP);
2527
2528 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_decrypt: done err = 0x0%x\n",
2529 instance, error));
2530
2531 return (error);
2532 }
2533
2534 /* ARGSUSED */
2535 static int
2536 dprov_decrypt_update(crypto_ctx_t *ctx, crypto_data_t *ciphertext,
2537 crypto_data_t *plaintext, crypto_req_handle_t req)
2538 {
2539 int error = CRYPTO_FAILED;
2540 dprov_state_t *softc;
2541 /* LINTED E_FUNC_SET_NOT_USED */
2542 int instance;
2543
2544 /* extract softc and instance number from context */
2545 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2546 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_decrypt_update: started\n",
2547 instance));
2548
2549 /* submit request to the taskq */
2550 error = dprov_cipher_submit_req(DPROV_REQ_DECRYPT_UPDATE, softc,
2551 req, NULL, NULL, plaintext, ciphertext, ctx, 0, KM_NOSLEEP);
2552
2553 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_decrypt_update: done err = 0x0%x\n",
2554 instance, error));
2555
2556 return (error);
2557 }
2558
2559 /* ARGSUSED */
2560 static int
2561 dprov_decrypt_final(crypto_ctx_t *ctx, crypto_data_t *plaintext,
2562 crypto_req_handle_t req)
2563 {
2564 int error = CRYPTO_FAILED;
2565 dprov_state_t *softc;
2566 /* LINTED E_FUNC_SET_NOT_USED */
2567 int instance;
2568
2569 /* extract softc and instance number from context */
2570 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2571 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_decrypt_final: started\n",
2572 instance));
2573
2574 /* submit request to the taskq */
2575 error = dprov_cipher_submit_req(DPROV_REQ_DECRYPT_FINAL, softc,
2576 req, NULL, NULL, plaintext, NULL, ctx, 0, KM_NOSLEEP);
2577
2578 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_decrypt_final: done err = 0x0%x\n",
2579 instance, error));
2580
2581 return (error);
2582 }
2583
2584 static int
2585 dprov_decrypt_atomic(crypto_provider_handle_t provider,
2586 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
2587 crypto_key_t *key, crypto_data_t *ciphertext, crypto_data_t *plaintext,
2588 crypto_spi_ctx_template_t ctx_template, crypto_req_handle_t req)
2589 {
2590 int error = CRYPTO_FAILED;
2591 dprov_state_t *softc = (dprov_state_t *)provider;
2592 /* LINTED E_FUNC_SET_NOT_USED */
2593 int instance;
2594
2595 instance = ddi_get_instance(softc->ds_dip);
2596 DPROV_DEBUG(D_MAC, ("(%d) dprov_decrypt_atomic: started\n", instance));
2597
2598 if (ctx_template != NULL)
2599 return (CRYPTO_ARGUMENTS_BAD);
2600
2601 /* check mechanism */
2602 if (!dprov_valid_cipher_mech(mechanism->cm_type)) {
2603 cmn_err(CE_WARN, "dprov_atomic_init: unexpected mech type "
2604 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2605 return (CRYPTO_MECHANISM_INVALID);
2606 }
2607
2608 error = dprov_cipher_submit_req(DPROV_REQ_DECRYPT_ATOMIC, softc,
2609 req, mechanism, key, plaintext, ciphertext, NULL, session_id,
2610 KM_SLEEP);
2611
2612 DPROV_DEBUG(D_MAC, ("(%d) dprov_decrypt_atomic: done err = 0x0%x\n",
2613 instance, error));
2614
2615 return (error);
2616 }
2617
2618 /*
2619 * Sign entry points.
2620 */
2621
2622 /*
2623 * Checks whether the specified mech_type is supported by sign/verify
2624 * entry points.
2625 */
2626 static boolean_t
2627 dprov_valid_sign_verif_mech(crypto_mech_type_t mech_type)
2628 {
2629 return (mech_type == MD5_HMAC_MECH_INFO_TYPE ||
2630 mech_type == MD5_HMAC_GEN_MECH_INFO_TYPE ||
2631 mech_type == SHA1_HMAC_MECH_INFO_TYPE ||
2632 mech_type == SHA1_HMAC_GEN_MECH_INFO_TYPE ||
2633 mech_type == SHA256_HMAC_MECH_INFO_TYPE ||
2634 mech_type == SHA256_HMAC_GEN_MECH_INFO_TYPE ||
2635 mech_type == SHA384_HMAC_MECH_INFO_TYPE ||
2636 mech_type == SHA384_HMAC_GEN_MECH_INFO_TYPE ||
2637 mech_type == SHA512_HMAC_MECH_INFO_TYPE ||
2638 mech_type == SHA512_HMAC_GEN_MECH_INFO_TYPE ||
2639 mech_type == RSA_PKCS_MECH_INFO_TYPE ||
2640 mech_type == RSA_X_509_MECH_INFO_TYPE ||
2641 mech_type == MD5_RSA_PKCS_MECH_INFO_TYPE ||
2642 mech_type == SHA1_RSA_PKCS_MECH_INFO_TYPE ||
2643 mech_type == SHA256_RSA_PKCS_MECH_INFO_TYPE ||
2644 mech_type == SHA384_RSA_PKCS_MECH_INFO_TYPE ||
2645 mech_type == SHA512_RSA_PKCS_MECH_INFO_TYPE ||
2646 mech_type == ECDSA_SHA1_MECH_INFO_TYPE ||
2647 mech_type == ECDSA_MECH_INFO_TYPE);
2648 }
2649
2650 static int
2651 dprov_sign_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
2652 crypto_key_t *key, crypto_spi_ctx_template_t ctx_template,
2653 crypto_req_handle_t req)
2654 {
2655 int error = CRYPTO_FAILED;
2656 dprov_state_t *softc;
2657 /* LINTED E_FUNC_SET_NOT_USED */
2658 int instance;
2659
2660 /* extract softc and instance number from context */
2661 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2662 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_init: started\n", instance));
2663
2664 /* check mechanism */
2665 if (!dprov_valid_sign_verif_mech(mechanism->cm_type)) {
2666 cmn_err(CE_WARN, "dprov_sign_init: unexpected mech type "
2667 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2668 return (CRYPTO_MECHANISM_INVALID);
2669 }
2670
2671 if (ctx_template != NULL)
2672 return (CRYPTO_ARGUMENTS_BAD);
2673
2674 /* submit request to the taskq */
2675 error = dprov_sign_submit_req(DPROV_REQ_SIGN_INIT, softc, req,
2676 mechanism, key, NULL, NULL, ctx, 0, KM_SLEEP);
2677
2678 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_init: done err = 0x%x\n",
2679 instance, error));
2680
2681 return (error);
2682 }
2683
2684 static int
2685 dprov_sign(crypto_ctx_t *ctx, crypto_data_t *data,
2686 crypto_data_t *signature, crypto_req_handle_t req)
2687 {
2688 int error = CRYPTO_FAILED;
2689 dprov_state_t *softc;
2690 /* LINTED E_FUNC_SET_NOT_USED */
2691 int instance;
2692
2693 /* extract softc and instance number from context */
2694 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2695 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign: started\n", instance));
2696
2697 /* submit request to the taskq */
2698 error = dprov_sign_submit_req(DPROV_REQ_SIGN, softc, req,
2699 NULL, NULL, data, signature, ctx, 0, KM_NOSLEEP);
2700
2701 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign: done err = 0x%x\n",
2702 instance, error));
2703
2704 return (error);
2705 }
2706
2707 static int
2708 dprov_sign_update(crypto_ctx_t *ctx, crypto_data_t *data,
2709 crypto_req_handle_t req)
2710 {
2711 int error = CRYPTO_FAILED;
2712 dprov_state_t *softc;
2713 /* LINTED E_FUNC_SET_NOT_USED */
2714 int instance;
2715
2716 /* extract softc and instance number from context */
2717 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2718 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_update: started\n", instance));
2719
2720 /* submit request to the taskq */
2721 error = dprov_sign_submit_req(DPROV_REQ_SIGN_UPDATE, softc, req,
2722 NULL, NULL, data, NULL, ctx, 0, KM_NOSLEEP);
2723
2724 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_update: done err = 0x%x\n",
2725 instance, error));
2726
2727 return (error);
2728 }
2729
2730 static int
2731 dprov_sign_final(crypto_ctx_t *ctx, crypto_data_t *signature,
2732 crypto_req_handle_t req)
2733 {
2734 int error = CRYPTO_FAILED;
2735 dprov_state_t *softc;
2736 /* LINTED E_FUNC_SET_NOT_USED */
2737 int instance;
2738
2739 /* extract softc and instance number from context */
2740 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2741 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_final: started\n", instance));
2742
2743 /* submit request to the taskq */
2744 error = dprov_sign_submit_req(DPROV_REQ_SIGN_FINAL, softc, req,
2745 NULL, NULL, NULL, signature, ctx, 0, KM_NOSLEEP);
2746
2747 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_final: done err = 0x%x\n",
2748 instance, error));
2749
2750 return (error);
2751 }
2752
2753 static int
2754 dprov_sign_atomic(crypto_provider_handle_t provider,
2755 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
2756 crypto_key_t *key, crypto_data_t *data, crypto_data_t *signature,
2757 crypto_spi_ctx_template_t ctx_template, crypto_req_handle_t req)
2758 {
2759 int error = CRYPTO_FAILED;
2760 dprov_state_t *softc = (dprov_state_t *)provider;
2761 /* LINTED E_FUNC_SET_NOT_USED */
2762 int instance;
2763
2764 instance = ddi_get_instance(softc->ds_dip);
2765 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_atomic: started\n", instance));
2766
2767 /* check mechanism */
2768 if (!dprov_valid_sign_verif_mech(mechanism->cm_type)) {
2769 cmn_err(CE_WARN, "dprov_sign_atomic: unexpected mech type "
2770 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2771 return (CRYPTO_MECHANISM_INVALID);
2772 }
2773
2774 if (ctx_template != NULL)
2775 return (CRYPTO_ARGUMENTS_BAD);
2776
2777 /* submit request to the taskq */
2778 error = dprov_sign_submit_req(DPROV_REQ_SIGN_ATOMIC, softc, req,
2779 mechanism, key, data, signature, NULL, session_id, KM_SLEEP);
2780
2781 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_atomic: done err = 0x%x\n",
2782 instance, error));
2783
2784 return (error);
2785 }
2786
2787 static int
2788 dprov_sign_recover_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
2789 crypto_key_t *key, crypto_spi_ctx_template_t ctx_template,
2790 crypto_req_handle_t req)
2791 {
2792 int error = CRYPTO_FAILED;
2793 dprov_state_t *softc;
2794 /* LINTED E_FUNC_SET_NOT_USED */
2795 int instance;
2796
2797 /* extract softc and instance number from context */
2798 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2799 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_recover_init: started\n",
2800 instance));
2801
2802 if (ctx_template != NULL)
2803 return (CRYPTO_ARGUMENTS_BAD);
2804
2805 /* submit request to the taskq */
2806 error = dprov_sign_submit_req(DPROV_REQ_SIGN_RECOVER_INIT, softc, req,
2807 mechanism, key, NULL, NULL, ctx, 0, KM_SLEEP);
2808
2809 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_recover_init: done err = 0x%x\n",
2810 instance, error));
2811
2812 return (error);
2813 }
2814
2815 static int
2816 dprov_sign_recover(crypto_ctx_t *ctx, crypto_data_t *data,
2817 crypto_data_t *signature, crypto_req_handle_t req)
2818 {
2819 int error = CRYPTO_FAILED;
2820 dprov_state_t *softc;
2821 /* LINTED E_FUNC_SET_NOT_USED */
2822 int instance;
2823
2824 /* extract softc and instance number from context */
2825 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2826 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_recover: started\n", instance));
2827
2828 /* submit request to the taskq */
2829 error = dprov_sign_submit_req(DPROV_REQ_SIGN_RECOVER, softc, req,
2830 NULL, NULL, data, signature, ctx, 0, KM_NOSLEEP);
2831
2832 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_recover: done err = 0x%x\n",
2833 instance, error));
2834
2835 return (error);
2836 }
2837
2838 static int
2839 dprov_sign_recover_atomic(crypto_provider_handle_t provider,
2840 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
2841 crypto_key_t *key, crypto_data_t *data, crypto_data_t *signature,
2842 crypto_spi_ctx_template_t ctx_template, crypto_req_handle_t req)
2843 {
2844 int error = CRYPTO_FAILED;
2845 dprov_state_t *softc = (dprov_state_t *)provider;
2846 /* LINTED E_FUNC_SET_NOT_USED */
2847 int instance;
2848
2849 instance = ddi_get_instance(softc->ds_dip);
2850 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_recover_atomic: started\n",
2851 instance));
2852
2853 if (ctx_template != NULL)
2854 return (CRYPTO_ARGUMENTS_BAD);
2855
2856 /* submit request to the taskq */
2857 error = dprov_sign_submit_req(DPROV_REQ_SIGN_RECOVER_ATOMIC, softc, req,
2858 mechanism, key, data, signature, NULL, session_id, KM_SLEEP);
2859
2860 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_recover_atomic: done "
2861 "err = 0x%x\n", instance, error));
2862
2863 return (error);
2864 }
2865
2866 /*
2867 * Verify entry points.
2868 */
2869
2870 static int
2871 dprov_verify_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
2872 crypto_key_t *key, crypto_spi_ctx_template_t ctx_template,
2873 crypto_req_handle_t req)
2874 {
2875 int error = CRYPTO_FAILED;
2876 dprov_state_t *softc;
2877 /* LINTED E_FUNC_SET_NOT_USED */
2878 int instance;
2879
2880 /* extract softc and instance number from context */
2881 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2882 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_init: started\n", instance));
2883
2884 /* check mechanism */
2885 if (!dprov_valid_sign_verif_mech(mechanism->cm_type)) {
2886 cmn_err(CE_WARN, "dprov_verify_init: unexpected mech type "
2887 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2888 return (CRYPTO_MECHANISM_INVALID);
2889 }
2890
2891 if (ctx_template != NULL)
2892 return (CRYPTO_ARGUMENTS_BAD);
2893
2894 error = dprov_verify_submit_req(DPROV_REQ_VERIFY_INIT, softc, req,
2895 mechanism, key, NULL, NULL, ctx, 0, KM_SLEEP);
2896
2897 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_init: done err = 0x%x\n",
2898 instance, error));
2899
2900 return (error);
2901 }
2902
2903 static int
2904 dprov_verify(crypto_ctx_t *ctx, crypto_data_t *data, crypto_data_t *signature,
2905 crypto_req_handle_t req)
2906 {
2907 int error = CRYPTO_FAILED;
2908 dprov_state_t *softc;
2909 /* LINTED E_FUNC_SET_NOT_USED */
2910 int instance;
2911
2912 /* extract softc and instance number from context */
2913 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2914 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify: started\n", instance));
2915
2916 /* submit request to the taskq */
2917 error = dprov_verify_submit_req(DPROV_REQ_VERIFY, softc, req,
2918 NULL, NULL, data, signature, ctx, 0, KM_NOSLEEP);
2919
2920 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify: done err = 0x%x\n",
2921 instance, error));
2922
2923 return (error);
2924 }
2925
2926 static int
2927 dprov_verify_update(crypto_ctx_t *ctx, crypto_data_t *data,
2928 crypto_req_handle_t req)
2929 {
2930 int error = CRYPTO_FAILED;
2931 dprov_state_t *softc;
2932 /* LINTED E_FUNC_SET_NOT_USED */
2933 int instance;
2934
2935 /* extract softc and instance number from context */
2936 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2937 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_update: started\n",
2938 instance));
2939
2940 /* submit request to the taskq */
2941 error = dprov_verify_submit_req(DPROV_REQ_VERIFY_UPDATE, softc, req,
2942 NULL, NULL, data, NULL, ctx, 0, KM_NOSLEEP);
2943
2944 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_update: done err = 0x%x\n",
2945 instance, error));
2946
2947 return (error);
2948 }
2949
2950 static int
2951 dprov_verify_final(crypto_ctx_t *ctx, crypto_data_t *signature,
2952 crypto_req_handle_t req)
2953 {
2954 int error = CRYPTO_FAILED;
2955 dprov_state_t *softc;
2956 /* LINTED E_FUNC_SET_NOT_USED */
2957 int instance;
2958
2959 /* extract softc and instance number from context */
2960 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
2961 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_final: started\n", instance));
2962
2963 /* submit request to the taskq */
2964 error = dprov_verify_submit_req(DPROV_REQ_VERIFY_FINAL, softc, req,
2965 NULL, NULL, NULL, signature, ctx, 0, KM_NOSLEEP);
2966
2967 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_final: done err = 0x%x\n",
2968 instance, error));
2969
2970 return (error);
2971 }
2972
2973 static int
2974 dprov_verify_atomic(crypto_provider_handle_t provider,
2975 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
2976 crypto_key_t *key, crypto_data_t *data, crypto_data_t *signature,
2977 crypto_spi_ctx_template_t ctx_template, crypto_req_handle_t req)
2978 {
2979 int error = CRYPTO_FAILED;
2980 dprov_state_t *softc = (dprov_state_t *)provider;
2981 /* LINTED E_FUNC_SET_NOT_USED */
2982 int instance;
2983
2984 instance = ddi_get_instance(softc->ds_dip);
2985 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_atomic: started\n",
2986 instance));
2987
2988 /* check mechanism */
2989 if (!dprov_valid_sign_verif_mech(mechanism->cm_type)) {
2990 cmn_err(CE_WARN, "dprov_verify_atomic: unexpected mech type "
2991 "0x%llx\n", (unsigned long long)mechanism->cm_type);
2992 return (CRYPTO_MECHANISM_INVALID);
2993 }
2994
2995 if (ctx_template != NULL)
2996 return (CRYPTO_ARGUMENTS_BAD);
2997
2998 /* submit request to the taskq */
2999 error = dprov_verify_submit_req(DPROV_REQ_VERIFY_ATOMIC, softc, req,
3000 mechanism, key, data, signature, NULL, session_id, KM_SLEEP);
3001
3002 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_atomic: done err = 0x%x\n",
3003 instance, error));
3004
3005 return (error);
3006 }
3007
3008 static int
3009 dprov_verify_recover_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
3010 crypto_key_t *key, crypto_spi_ctx_template_t ctx_template,
3011 crypto_req_handle_t req)
3012 {
3013 int error = CRYPTO_FAILED;
3014 dprov_state_t *softc;
3015 /* LINTED E_FUNC_SET_NOT_USED */
3016 int instance;
3017
3018 /* extract softc and instance number from context */
3019 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3020 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_recover_init: started\n",
3021 instance));
3022
3023 if (ctx_template != NULL)
3024 return (CRYPTO_ARGUMENTS_BAD);
3025
3026 /* submit request to the taskq */
3027 error = dprov_verify_submit_req(DPROV_REQ_VERIFY_RECOVER_INIT, softc,
3028 req, mechanism, key, NULL, NULL, ctx, 0, KM_SLEEP);
3029
3030 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_recover_init: done "
3031 "err = 0x%x\n", instance, error));
3032
3033 return (error);
3034 }
3035
3036 static int
3037 dprov_verify_recover(crypto_ctx_t *ctx, crypto_data_t *signature,
3038 crypto_data_t *data, crypto_req_handle_t req)
3039 {
3040 int error = CRYPTO_FAILED;
3041 dprov_state_t *softc;
3042 /* LINTED E_FUNC_SET_NOT_USED */
3043 int instance;
3044
3045 /* extract softc and instance number from context */
3046 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3047 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_recover: started\n",
3048 instance));
3049
3050 /* submit request to the taskq */
3051 error = dprov_verify_submit_req(DPROV_REQ_VERIFY_RECOVER, softc, req,
3052 NULL, NULL, data, signature, ctx, 0, KM_NOSLEEP);
3053
3054 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_recover: done err = 0x%x\n",
3055 instance, error));
3056
3057 return (error);
3058 }
3059
3060 static int
3061 dprov_verify_recover_atomic(crypto_provider_handle_t provider,
3062 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
3063 crypto_key_t *key, crypto_data_t *signature, crypto_data_t *data,
3064 crypto_spi_ctx_template_t ctx_template, crypto_req_handle_t req)
3065 {
3066 int error = CRYPTO_FAILED;
3067 dprov_state_t *softc = (dprov_state_t *)provider;
3068 /* LINTED E_FUNC_SET_NOT_USED */
3069 int instance;
3070
3071 instance = ddi_get_instance(softc->ds_dip);
3072 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_recover_atomic: started\n",
3073 instance));
3074
3075 if (ctx_template != NULL)
3076 return (CRYPTO_ARGUMENTS_BAD);
3077
3078 /* submit request to the taskq */
3079 error = dprov_verify_submit_req(DPROV_REQ_VERIFY_RECOVER_ATOMIC, softc,
3080 req, mechanism, key, data, signature, NULL, session_id, KM_SLEEP);
3081
3082 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_recover_atomic: done "
3083 "err = 0x%x\n", instance, error));
3084
3085 return (error);
3086 }
3087
3088 /*
3089 * Dual operations entry points.
3090 */
3091
3092 static int
3093 dprov_digest_encrypt_update(crypto_ctx_t *digest_ctx,
3094 crypto_ctx_t *encrypt_ctx, crypto_data_t *plaintext,
3095 crypto_data_t *ciphertext, crypto_req_handle_t req)
3096 {
3097 int error = CRYPTO_FAILED;
3098 dprov_state_t *softc;
3099 /* LINTED E_FUNC_SET_NOT_USED */
3100 int instance;
3101
3102 /* extract softc and instance number from context */
3103 DPROV_SOFTC_FROM_CTX(digest_ctx, softc, instance);
3104 DPROV_DEBUG(D_DUAL, ("(%d) dprov_digest_encrypt_update: started\n",
3105 instance));
3106
3107 if (digest_ctx->cc_provider != encrypt_ctx->cc_provider)
3108 return (CRYPTO_INVALID_CONTEXT);
3109
3110 /* submit request to the taskq */
3111 error = dprov_dual_submit_req(DPROV_REQ_DIGEST_ENCRYPT_UPDATE,
3112 softc, req, digest_ctx, encrypt_ctx, plaintext, ciphertext);
3113
3114 DPROV_DEBUG(D_DUAL, ("(%d) dprov_digest_encrypt_update: done "
3115 "err = 0x%x\n", instance, error));
3116
3117 return (error);
3118 }
3119
3120 static int
3121 dprov_decrypt_digest_update(crypto_ctx_t *decrypt_ctx, crypto_ctx_t *digest_ctx,
3122 crypto_data_t *ciphertext, crypto_data_t *plaintext,
3123 crypto_req_handle_t req)
3124 {
3125 int error = CRYPTO_FAILED;
3126 dprov_state_t *softc;
3127 /* LINTED E_FUNC_SET_NOT_USED */
3128 int instance;
3129
3130 /* extract softc and instance number from context */
3131 DPROV_SOFTC_FROM_CTX(decrypt_ctx, softc, instance);
3132 DPROV_DEBUG(D_DUAL, ("(%d) dprov_decrypt_digest_update: started\n",
3133 instance));
3134
3135 if (decrypt_ctx->cc_provider != digest_ctx->cc_provider)
3136 return (CRYPTO_INVALID_CONTEXT);
3137
3138 /* submit request to the taskq */
3139 error = dprov_dual_submit_req(DPROV_REQ_DECRYPT_DIGEST_UPDATE,
3140 softc, req, digest_ctx, decrypt_ctx, plaintext, ciphertext);
3141
3142 DPROV_DEBUG(D_DUAL, ("(%d) dprov_decrypt_digest_update: done "
3143 "err = 0x%x\n", instance, error));
3144
3145 return (error);
3146 }
3147
3148 static int
3149 dprov_sign_encrypt_update(crypto_ctx_t *sign_ctx, crypto_ctx_t *encrypt_ctx,
3150 crypto_data_t *plaintext, crypto_data_t *ciphertext,
3151 crypto_req_handle_t req)
3152 {
3153 int error = CRYPTO_FAILED;
3154 dprov_state_t *softc;
3155 /* LINTED E_FUNC_SET_NOT_USED */
3156 int instance;
3157
3158 /* extract softc and instance number from context */
3159 DPROV_SOFTC_FROM_CTX(sign_ctx, softc, instance);
3160 DPROV_DEBUG(D_DUAL, ("(%d) dprov_sign_encrypt_update: started\n",
3161 instance));
3162
3163 if (sign_ctx->cc_provider != encrypt_ctx->cc_provider)
3164 return (CRYPTO_INVALID_CONTEXT);
3165
3166 /* submit request to the taskq */
3167 error = dprov_dual_submit_req(DPROV_REQ_SIGN_ENCRYPT_UPDATE,
3168 softc, req, sign_ctx, encrypt_ctx, plaintext, ciphertext);
3169
3170 DPROV_DEBUG(D_DUAL, ("(%d) dprov_sign_encrypt_update: done "
3171 "err = 0x%x\n", instance, error));
3172
3173 return (error);
3174 }
3175
3176 static int
3177 dprov_decrypt_verify_update(crypto_ctx_t *decrypt_ctx, crypto_ctx_t *verify_ctx,
3178 crypto_data_t *ciphertext, crypto_data_t *plaintext,
3179 crypto_req_handle_t req)
3180 {
3181 int error = CRYPTO_FAILED;
3182 dprov_state_t *softc;
3183 /* LINTED E_FUNC_SET_NOT_USED */
3184 int instance;
3185
3186 /* extract softc and instance number from context */
3187 DPROV_SOFTC_FROM_CTX(decrypt_ctx, softc, instance);
3188 DPROV_DEBUG(D_DUAL, ("(%d) dprov_decrypt_verify_update: started\n",
3189 instance));
3190
3191 if (decrypt_ctx->cc_provider != verify_ctx->cc_provider)
3192 return (CRYPTO_INVALID_CONTEXT);
3193
3194 /* submit request to the taskq */
3195 error = dprov_dual_submit_req(DPROV_REQ_DECRYPT_VERIFY_UPDATE,
3196 softc, req, verify_ctx, decrypt_ctx, plaintext, ciphertext);
3197
3198 DPROV_DEBUG(D_DUAL, ("(%d) dprov_decrypt_verify_update: done "
3199 "err = 0x%x\n", instance, error));
3200
3201 return (error);
3202 }
3203
3204 /*
3205 * Dual cipher-mac entry points.
3206 */
3207
3208 static int
3209 dprov_encrypt_mac_init(crypto_ctx_t *ctx, crypto_mechanism_t *encrypt_mech,
3210 crypto_key_t *encrypt_key, crypto_mechanism_t *mac_mech,
3211 crypto_key_t *mac_key, crypto_spi_ctx_template_t encr_ctx_template,
3212 crypto_spi_ctx_template_t mac_ctx_template,
3213 crypto_req_handle_t req)
3214 {
3215 int error = CRYPTO_FAILED;
3216 dprov_state_t *softc;
3217 /* LINTED E_FUNC_SET_NOT_USED */
3218 int instance;
3219
3220 /* extract softc and instance number from context */
3221 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3222 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac_init: started\n",
3223 instance));
3224
3225 /* check mechanisms */
3226 if (!dprov_valid_cipher_mech(encrypt_mech->cm_type)) {
3227 cmn_err(CE_WARN, "dprov_encrypt_mac_init: unexpected encrypt "
3228 "mech type 0x%llx\n",
3229 (unsigned long long)encrypt_mech->cm_type);
3230 return (CRYPTO_MECHANISM_INVALID);
3231 }
3232 if (!dprov_valid_mac_mech(mac_mech->cm_type)) {
3233 cmn_err(CE_WARN, "dprov_encrypt_mac_init: unexpected mac "
3234 "mech type 0x%llx\n",
3235 (unsigned long long)mac_mech->cm_type);
3236 return (CRYPTO_MECHANISM_INVALID);
3237 }
3238
3239 if (encr_ctx_template != NULL || mac_ctx_template != NULL)
3240 return (CRYPTO_ARGUMENTS_BAD);
3241
3242 /* submit request to the taskq */
3243 error = dprov_cipher_mac_submit_req(DPROV_REQ_ENCRYPT_MAC_INIT,
3244 softc, req, ctx, 0, encrypt_mech, encrypt_key, mac_mech, mac_key,
3245 NULL, NULL, NULL, KM_SLEEP);
3246
3247 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac_init: done "
3248 "err = 0x%x\n", instance, error));
3249
3250 return (error);
3251 }
3252
3253 static int
3254 dprov_encrypt_mac(crypto_ctx_t *ctx, crypto_data_t *plaintext,
3255 crypto_dual_data_t *ciphertext, crypto_data_t *mac, crypto_req_handle_t req)
3256 {
3257 int error = CRYPTO_FAILED;
3258 dprov_state_t *softc;
3259 /* LINTED E_FUNC_SET_NOT_USED */
3260 int instance;
3261
3262 /* extract softc and instance number from context */
3263 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3264 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac: started\n",
3265 instance));
3266
3267 /*
3268 * submit request to the taskq
3269 * Careful! cihertext/plaintext order inversion
3270 */
3271 error = dprov_cipher_mac_submit_req(DPROV_REQ_ENCRYPT_MAC,
3272 softc, req, ctx, 0, NULL, NULL, NULL, NULL,
3273 ciphertext, plaintext, mac, KM_NOSLEEP);
3274
3275 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac: done "
3276 "err = 0x%x\n", instance, error));
3277
3278 return (error);
3279 }
3280
3281 static int
3282 dprov_encrypt_mac_update(crypto_ctx_t *ctx, crypto_data_t *plaintext,
3283 crypto_dual_data_t *ciphertext, crypto_req_handle_t req)
3284 {
3285 int error = CRYPTO_FAILED;
3286 dprov_state_t *softc;
3287 /* LINTED E_FUNC_SET_NOT_USED */
3288 int instance;
3289
3290 /* extract softc and instance number from context */
3291 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3292 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac_update: started\n",
3293 instance));
3294
3295 /* submit request to the taskq */
3296 error = dprov_cipher_mac_submit_req(DPROV_REQ_ENCRYPT_MAC_UPDATE,
3297 softc, req, ctx, 0, NULL, NULL, NULL, NULL,
3298 ciphertext, plaintext, NULL, KM_NOSLEEP);
3299
3300 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac_update: done "
3301 "err = 0x%x\n", instance, error));
3302
3303 return (error);
3304 }
3305
3306 static int
3307 dprov_encrypt_mac_final(crypto_ctx_t *ctx,
3308 crypto_dual_data_t *ciphertext, crypto_data_t *mac,
3309 crypto_req_handle_t req)
3310 {
3311 int error = CRYPTO_FAILED;
3312 dprov_state_t *softc;
3313 /* LINTED E_FUNC_SET_NOT_USED */
3314 int instance;
3315
3316 /* extract softc and instance number from context */
3317 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3318 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac_final: started\n",
3319 instance));
3320
3321 /* submit request to the taskq */
3322 error = dprov_cipher_mac_submit_req(DPROV_REQ_ENCRYPT_MAC_FINAL,
3323 softc, req, ctx, 0, NULL, NULL, NULL, NULL,
3324 ciphertext, NULL, mac, KM_NOSLEEP);
3325
3326 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac_final: done "
3327 "err = 0x%x\n", instance, error));
3328
3329 return (error);
3330 }
3331
3332 static int
3333 dprov_encrypt_mac_atomic(crypto_provider_handle_t provider,
3334 crypto_session_id_t session_id, crypto_mechanism_t *encrypt_mech,
3335 crypto_key_t *encrypt_key, crypto_mechanism_t *mac_mech,
3336 crypto_key_t *mac_key, crypto_data_t *plaintext,
3337 crypto_dual_data_t *ciphertext, crypto_data_t *mac,
3338 crypto_spi_ctx_template_t encr_ctx_template,
3339 crypto_spi_ctx_template_t mac_ctx_template,
3340 crypto_req_handle_t req)
3341 {
3342 int error = CRYPTO_FAILED;
3343 dprov_state_t *softc = (dprov_state_t *)provider;
3344 /* LINTED E_FUNC_SET_NOT_USED */
3345 int instance;
3346
3347 instance = ddi_get_instance(softc->ds_dip);
3348 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac_atomic: started\n",
3349 instance));
3350
3351 /* check mechanisms */
3352 if (!dprov_valid_cipher_mech(encrypt_mech->cm_type)) {
3353 cmn_err(CE_WARN, "dprov_encrypt_mac_atomic: unexpected encrypt "
3354 "mech type 0x%llx\n",
3355 (unsigned long long)encrypt_mech->cm_type);
3356 return (CRYPTO_MECHANISM_INVALID);
3357 }
3358 if (!dprov_valid_mac_mech(mac_mech->cm_type)) {
3359 cmn_err(CE_WARN, "dprov_encrypt_mac_atomic: unexpected mac "
3360 "mech type 0x%llx\n",
3361 (unsigned long long)mac_mech->cm_type);
3362 return (CRYPTO_MECHANISM_INVALID);
3363 }
3364
3365 if (encr_ctx_template != NULL || mac_ctx_template != NULL)
3366 return (CRYPTO_ARGUMENTS_BAD);
3367
3368 /* submit request to the taskq */
3369 error = dprov_cipher_mac_submit_req(DPROV_REQ_ENCRYPT_MAC_ATOMIC,
3370 softc, req, NULL, session_id, encrypt_mech, encrypt_key, mac_mech,
3371 mac_key, ciphertext, plaintext, mac, KM_SLEEP);
3372
3373 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_encrypt_mac_atomic: done "
3374 "err = 0x%x\n", instance, error));
3375
3376 return (error);
3377 }
3378
3379 static int
3380 dprov_mac_decrypt_init(crypto_ctx_t *ctx, crypto_mechanism_t *mac_mech,
3381 crypto_key_t *mac_key, crypto_mechanism_t *decrypt_mech,
3382 crypto_key_t *decrypt_key, crypto_spi_ctx_template_t mac_ctx_template,
3383 crypto_spi_ctx_template_t decr_ctx_template,
3384 crypto_req_handle_t req)
3385 {
3386 int error = CRYPTO_FAILED;
3387 dprov_state_t *softc;
3388 /* LINTED E_FUNC_SET_NOT_USED */
3389 int instance;
3390
3391 /* extract softc and instance number from context */
3392 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3393 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt_init: started\n",
3394 instance));
3395
3396 /* check mechanisms */
3397 if (!dprov_valid_cipher_mech(decrypt_mech->cm_type)) {
3398 cmn_err(CE_WARN, "dprov_mac_decrypt_init: unexpected decrypt "
3399 "mech type 0x%llx\n",
3400 (unsigned long long)decrypt_mech->cm_type);
3401 return (CRYPTO_MECHANISM_INVALID);
3402 }
3403 if (!dprov_valid_mac_mech(mac_mech->cm_type)) {
3404 cmn_err(CE_WARN, "dprov_mac_decrypt_init: unexpected mac "
3405 "mech type 0x%llx\n",
3406 (unsigned long long)mac_mech->cm_type);
3407 return (CRYPTO_MECHANISM_INVALID);
3408 }
3409
3410 if (decr_ctx_template != NULL || mac_ctx_template != NULL)
3411 return (CRYPTO_ARGUMENTS_BAD);
3412
3413 /* submit request to the taskq */
3414 error = dprov_cipher_mac_submit_req(DPROV_REQ_MAC_DECRYPT_INIT,
3415 softc, req, ctx, 0, decrypt_mech, decrypt_key, mac_mech, mac_key,
3416 NULL, NULL, NULL, KM_SLEEP);
3417
3418 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt_init: done "
3419 "err = 0x%x\n", instance, error));
3420
3421 return (error);
3422 }
3423
3424 static int
3425 dprov_mac_decrypt(crypto_ctx_t *ctx, crypto_dual_data_t *ciphertext,
3426 crypto_data_t *mac, crypto_data_t *plaintext, crypto_req_handle_t req)
3427 {
3428 int error = CRYPTO_FAILED;
3429 dprov_state_t *softc;
3430 /* LINTED E_FUNC_SET_NOT_USED */
3431 int instance;
3432
3433 /* extract softc and instance number from context */
3434 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3435 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt: started\n",
3436 instance));
3437
3438 /* submit request to the taskq */
3439 error = dprov_cipher_mac_submit_req(DPROV_REQ_MAC_DECRYPT,
3440 softc, req, ctx, 0, NULL, NULL, NULL, NULL,
3441 ciphertext, plaintext, mac, KM_NOSLEEP);
3442
3443 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt: done "
3444 "err = 0x%x\n", instance, error));
3445
3446 return (error);
3447 }
3448
3449 static int
3450 dprov_mac_decrypt_update(crypto_ctx_t *ctx, crypto_dual_data_t *ciphertext,
3451 crypto_data_t *plaintext, crypto_req_handle_t req)
3452 {
3453 int error = CRYPTO_FAILED;
3454 dprov_state_t *softc;
3455 /* LINTED E_FUNC_SET_NOT_USED */
3456 int instance;
3457
3458 /* extract softc and instance number from context */
3459 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3460 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt_update: started\n",
3461 instance));
3462
3463 /* submit request to the taskq */
3464 error = dprov_cipher_mac_submit_req(DPROV_REQ_MAC_DECRYPT_UPDATE,
3465 softc, req, ctx, 0, NULL, NULL, NULL, NULL,
3466 ciphertext, plaintext, NULL, KM_NOSLEEP);
3467
3468 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt_update: done "
3469 "err = 0x%x\n", instance, error));
3470
3471 return (error);
3472 }
3473
3474 static int
3475 dprov_mac_decrypt_final(crypto_ctx_t *ctx, crypto_data_t *mac,
3476 crypto_data_t *plaintext, crypto_req_handle_t req)
3477 {
3478 int error = CRYPTO_FAILED;
3479 dprov_state_t *softc;
3480 /* LINTED E_FUNC_SET_NOT_USED */
3481 int instance;
3482
3483 /* extract softc and instance number from context */
3484 DPROV_SOFTC_FROM_CTX(ctx, softc, instance);
3485 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt_final: started\n",
3486 instance));
3487
3488 /* submit request to the taskq */
3489 error = dprov_cipher_mac_submit_req(DPROV_REQ_MAC_DECRYPT_FINAL,
3490 softc, req, ctx, 0, NULL, NULL, NULL, NULL,
3491 NULL, plaintext, mac, KM_NOSLEEP);
3492
3493 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt_final: done "
3494 "err = 0x%x\n", instance, error));
3495
3496 return (error);
3497 }
3498
3499 static int
3500 dprov_mac_decrypt_atomic(crypto_provider_handle_t provider,
3501 crypto_session_id_t session_id, crypto_mechanism_t *mac_mech,
3502 crypto_key_t *mac_key, crypto_mechanism_t *decrypt_mech,
3503 crypto_key_t *decrypt_key, crypto_dual_data_t *ciphertext,
3504 crypto_data_t *mac, crypto_data_t *plaintext,
3505 crypto_spi_ctx_template_t mac_ctx_template,
3506 crypto_spi_ctx_template_t decr_ctx_template,
3507 crypto_req_handle_t req)
3508 {
3509 int error = CRYPTO_FAILED;
3510 dprov_state_t *softc = (dprov_state_t *)provider;
3511 /* LINTED E_FUNC_SET_NOT_USED */
3512 int instance;
3513
3514 instance = ddi_get_instance(softc->ds_dip);
3515 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt_atomic: started\n",
3516 instance));
3517
3518 /* check mechanisms */
3519 if (!dprov_valid_cipher_mech(decrypt_mech->cm_type)) {
3520 cmn_err(CE_WARN, "dprov_mac_decrypt_atomic: unexpected encrypt "
3521 "mech type 0x%llx\n",
3522 (unsigned long long)decrypt_mech->cm_type);
3523 return (CRYPTO_MECHANISM_INVALID);
3524 }
3525 if (!dprov_valid_mac_mech(mac_mech->cm_type)) {
3526 cmn_err(CE_WARN, "dprov_mac_decrypt_atomic: unexpected mac "
3527 "mech type 0x%llx\n",
3528 (unsigned long long)mac_mech->cm_type);
3529 return (CRYPTO_MECHANISM_INVALID);
3530 }
3531
3532 if (decr_ctx_template != NULL || mac_ctx_template != NULL)
3533 return (CRYPTO_ARGUMENTS_BAD);
3534
3535 /* submit request to the taskq */
3536 error = dprov_cipher_mac_submit_req(DPROV_REQ_MAC_DECRYPT_ATOMIC,
3537 softc, req, NULL, session_id, decrypt_mech, decrypt_key, mac_mech,
3538 mac_key, ciphertext, plaintext, mac, KM_SLEEP);
3539
3540 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_decrypt_atomic: done "
3541 "err = 0x%x\n", instance, error));
3542
3543 return (error);
3544 }
3545
3546 static int
3547 dprov_mac_verify_decrypt_atomic(crypto_provider_handle_t provider,
3548 crypto_session_id_t session_id, crypto_mechanism_t *mac_mech,
3549 crypto_key_t *mac_key, crypto_mechanism_t *decrypt_mech,
3550 crypto_key_t *decrypt_key, crypto_dual_data_t *ciphertext,
3551 crypto_data_t *mac, crypto_data_t *plaintext,
3552 crypto_spi_ctx_template_t mac_ctx_template,
3553 crypto_spi_ctx_template_t decr_ctx_template,
3554 crypto_req_handle_t req)
3555 {
3556 int error = CRYPTO_FAILED;
3557 dprov_state_t *softc = (dprov_state_t *)provider;
3558 /* LINTED E_FUNC_SET_NOT_USED */
3559 int instance;
3560
3561 instance = ddi_get_instance(softc->ds_dip);
3562 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_verify_decrypt_atomic:"
3563 "started\n", instance));
3564
3565 /* check mechanisms */
3566 if (!dprov_valid_cipher_mech(decrypt_mech->cm_type)) {
3567 cmn_err(CE_WARN, "dprov_mac_verify_decrypt_atomic: "
3568 "unexpected encrypt mech type 0x%llx\n",
3569 (unsigned long long)decrypt_mech->cm_type);
3570 return (CRYPTO_MECHANISM_INVALID);
3571 }
3572 if (!dprov_valid_mac_mech(mac_mech->cm_type)) {
3573 cmn_err(CE_WARN, "dprov_mac_verify_decrypt_atomic: "
3574 "unexpected mac mech type 0x%llx\n",
3575 (unsigned long long)mac_mech->cm_type);
3576 return (CRYPTO_MECHANISM_INVALID);
3577 }
3578
3579 if (decr_ctx_template != NULL || mac_ctx_template != NULL)
3580 return (CRYPTO_ARGUMENTS_BAD);
3581
3582 /* submit request to the taskq */
3583 error = dprov_cipher_mac_submit_req(DPROV_REQ_MAC_VERIFY_DECRYPT_ATOMIC,
3584 softc, req, NULL, session_id, decrypt_mech, decrypt_key, mac_mech,
3585 mac_key, ciphertext, plaintext, mac, KM_SLEEP);
3586
3587 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_mac_verify_decrypt_atomic: done "
3588 "err = 0x%x\n", instance, error));
3589
3590 return (error);
3591 }
3592
3593 /*
3594 * Random number entry points.
3595 */
3596
3597 static int
3598 dprov_seed_random(crypto_provider_handle_t provider, crypto_session_id_t sid,
3599 uchar_t *buf, size_t len, uint_t entropy_est, uint32_t flags,
3600 crypto_req_handle_t req)
3601 {
3602 int error = CRYPTO_FAILED;
3603 dprov_state_t *softc = (dprov_state_t *)provider;
3604 /* LINTED E_FUNC_SET_NOT_USED */
3605 int instance;
3606
3607 instance = ddi_get_instance(softc->ds_dip);
3608 DPROV_DEBUG(D_RANDOM, ("(%d) dprov_seed_random: started\n",
3609 instance));
3610
3611 error = dprov_random_submit_req(DPROV_REQ_RANDOM_SEED, softc,
3612 req, buf, len, sid, entropy_est, flags);
3613
3614 DPROV_DEBUG(D_RANDOM, ("(%d) dprov_seed_random: done err = 0x0%x\n",
3615 instance, error));
3616
3617 return (error);
3618 }
3619
3620 static int
3621 dprov_generate_random(crypto_provider_handle_t provider,
3622 crypto_session_id_t sid, uchar_t *buf, size_t len, crypto_req_handle_t req)
3623 {
3624 int error = CRYPTO_FAILED;
3625 dprov_state_t *softc = (dprov_state_t *)provider;
3626 /* LINTED E_FUNC_SET_NOT_USED */
3627 int instance;
3628
3629 instance = ddi_get_instance(softc->ds_dip);
3630 DPROV_DEBUG(D_RANDOM, ("(%d) dprov_generate_random: started\n",
3631 instance));
3632
3633 error = dprov_random_submit_req(DPROV_REQ_RANDOM_GENERATE, softc,
3634 req, buf, len, sid, 0, 0);
3635
3636 DPROV_DEBUG(D_RANDOM, ("(%d) dprov_generate_random: done "
3637 "err = 0x0%x\n", instance, error));
3638
3639 return (error);
3640 }
3641
3642 /*
3643 * Session Management entry points.
3644 */
3645
3646 static int
3647 dprov_session_open(crypto_provider_handle_t provider,
3648 crypto_session_id_t *session_id, crypto_req_handle_t req)
3649 {
3650 int error = CRYPTO_FAILED;
3651 dprov_state_t *softc = (dprov_state_t *)provider;
3652 /* LINTED E_FUNC_SET_NOT_USED */
3653 int instance;
3654
3655 instance = ddi_get_instance(softc->ds_dip);
3656 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_open: started\n",
3657 instance));
3658
3659 error = dprov_session_submit_req(DPROV_REQ_SESSION_OPEN, softc,
3660 req, session_id, 0, 0, NULL, 0);
3661
3662 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_open: done err = 0x0%x\n",
3663 instance, error));
3664
3665 return (error);
3666 }
3667
3668 static int
3669 dprov_session_close(crypto_provider_handle_t provider,
3670 crypto_session_id_t session_id, crypto_req_handle_t req)
3671 {
3672 int error = CRYPTO_FAILED;
3673 dprov_state_t *softc = (dprov_state_t *)provider;
3674 /* LINTED E_FUNC_SET_NOT_USED */
3675 int instance;
3676
3677 instance = ddi_get_instance(softc->ds_dip);
3678 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_close: started\n",
3679 instance));
3680
3681 error = dprov_session_submit_req(DPROV_REQ_SESSION_CLOSE, softc,
3682 req, 0, session_id, 0, NULL, 0);
3683
3684 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_close: done err = 0x0%x\n",
3685 instance, error));
3686
3687 return (error);
3688 }
3689
3690 static int
3691 dprov_session_login(crypto_provider_handle_t provider,
3692 crypto_session_id_t session_id, crypto_user_type_t user_type,
3693 char *pin, size_t pin_len, crypto_req_handle_t req)
3694 {
3695 int error = CRYPTO_FAILED;
3696 dprov_state_t *softc = (dprov_state_t *)provider;
3697 /* LINTED E_FUNC_SET_NOT_USED */
3698 int instance;
3699
3700 instance = ddi_get_instance(softc->ds_dip);
3701 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_login: started\n",
3702 instance));
3703
3704 error = dprov_session_submit_req(DPROV_REQ_SESSION_LOGIN, softc,
3705 req, 0, session_id, user_type, pin, pin_len);
3706
3707 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_login: done err = 0x0%x\n",
3708 instance, error));
3709
3710 return (error);
3711 }
3712
3713 static int
3714 dprov_session_logout(crypto_provider_handle_t provider,
3715 crypto_session_id_t session_id, crypto_req_handle_t req)
3716 {
3717 int error = CRYPTO_FAILED;
3718 dprov_state_t *softc = (dprov_state_t *)provider;
3719 /* LINTED E_FUNC_SET_NOT_USED */
3720 int instance;
3721
3722 instance = ddi_get_instance(softc->ds_dip);
3723 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_logout: started\n",
3724 instance));
3725
3726 error = dprov_session_submit_req(DPROV_REQ_SESSION_LOGOUT, softc,
3727 req, 0, session_id, 0, NULL, 0);
3728
3729 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_logout: done err = 0x0%x\n",
3730 instance, error));
3731
3732 return (error);
3733 }
3734
3735 /*
3736 * Object management entry points.
3737 */
3738
3739 static int
3740 dprov_object_create(crypto_provider_handle_t provider,
3741 crypto_session_id_t session_id, crypto_object_attribute_t *template,
3742 uint_t attribute_count, crypto_object_id_t *object,
3743 crypto_req_handle_t req)
3744 {
3745 int error = CRYPTO_FAILED;
3746 dprov_state_t *softc = (dprov_state_t *)provider;
3747 /* LINTED E_FUNC_SET_NOT_USED */
3748 int instance;
3749
3750 instance = ddi_get_instance(softc->ds_dip);
3751 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_create: started\n",
3752 instance));
3753
3754 /* submit request to the taskq */
3755 error = dprov_object_submit_req(DPROV_REQ_OBJECT_CREATE, softc, req,
3756 session_id, 0, template, attribute_count, object, NULL, NULL,
3757 NULL, 0, NULL, KM_NOSLEEP);
3758
3759 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_create: done err = 0x0%x\n",
3760 instance, error));
3761
3762 return (error);
3763 }
3764
3765 static int
3766 dprov_object_copy(crypto_provider_handle_t provider,
3767 crypto_session_id_t session_id, crypto_object_id_t object,
3768 crypto_object_attribute_t *template, uint_t attribute_count,
3769 crypto_object_id_t *new_object, crypto_req_handle_t req)
3770 {
3771 int error = CRYPTO_FAILED;
3772 dprov_state_t *softc = (dprov_state_t *)provider;
3773 /* LINTED E_FUNC_SET_NOT_USED */
3774 int instance;
3775
3776 instance = ddi_get_instance(softc->ds_dip);
3777 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_copy: started\n",
3778 instance));
3779
3780 /* submit request to the taskq */
3781 error = dprov_object_submit_req(DPROV_REQ_OBJECT_COPY, softc, req,
3782 session_id, object, template, attribute_count, new_object,
3783 NULL, NULL, NULL, 0, NULL, KM_NOSLEEP);
3784
3785 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_copy: done err = 0x0%x\n",
3786 instance, error));
3787
3788 return (error);
3789 }
3790
3791 static int
3792 dprov_object_destroy(crypto_provider_handle_t provider,
3793 crypto_session_id_t session_id, crypto_object_id_t object,
3794 crypto_req_handle_t req)
3795 {
3796 int error = CRYPTO_FAILED;
3797 dprov_state_t *softc = (dprov_state_t *)provider;
3798 /* LINTED E_FUNC_SET_NOT_USED */
3799 int instance;
3800
3801 instance = ddi_get_instance(softc->ds_dip);
3802 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_destroy: started\n",
3803 instance));
3804
3805 /* submit request to the taskq */
3806 error = dprov_object_submit_req(DPROV_REQ_OBJECT_DESTROY, softc, req,
3807 session_id, object, NULL, 0, NULL, NULL, NULL, NULL, 0, NULL,
3808 KM_NOSLEEP);
3809
3810 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_destroy: done err = 0x0%x\n",
3811 instance, error));
3812
3813 return (error);
3814 }
3815
3816 static int
3817 dprov_object_get_size(crypto_provider_handle_t provider,
3818 crypto_session_id_t session_id, crypto_object_id_t object,
3819 size_t *size, crypto_req_handle_t req)
3820 {
3821 int error = CRYPTO_FAILED;
3822 dprov_state_t *softc = (dprov_state_t *)provider;
3823 /* LINTED E_FUNC_SET_NOT_USED */
3824 int instance;
3825
3826 instance = ddi_get_instance(softc->ds_dip);
3827 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_get_size: started\n",
3828 instance));
3829
3830 /* submit request to the taskq */
3831 error = dprov_object_submit_req(DPROV_REQ_OBJECT_GET_SIZE, softc, req,
3832 session_id, object, NULL, 0, NULL, size, NULL, NULL, 0, NULL,
3833 KM_NOSLEEP);
3834
3835 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_get_size: done err = 0x0%x\n",
3836 instance, error));
3837
3838 return (error);
3839 }
3840
3841 static int
3842 dprov_object_get_attribute_value(crypto_provider_handle_t provider,
3843 crypto_session_id_t session_id, crypto_object_id_t object,
3844 crypto_object_attribute_t *template, uint_t attribute_count,
3845 crypto_req_handle_t req)
3846 {
3847 int error = CRYPTO_FAILED;
3848 dprov_state_t *softc = (dprov_state_t *)provider;
3849 /* LINTED E_FUNC_SET_NOT_USED */
3850 int instance;
3851
3852 instance = ddi_get_instance(softc->ds_dip);
3853 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_get_attribute_value: "
3854 "started\n", instance));
3855
3856 /* submit request to the taskq */
3857 error = dprov_object_submit_req(DPROV_REQ_OBJECT_GET_ATTRIBUTE_VALUE,
3858 softc, req, session_id, object, template, attribute_count,
3859 NULL, NULL, NULL, NULL, 0, NULL, KM_NOSLEEP);
3860
3861 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_get_attribute_value: "
3862 "done err = 0x0%x\n", instance, error));
3863
3864 return (error);
3865 }
3866
3867 static int
3868 dprov_object_set_attribute_value(crypto_provider_handle_t provider,
3869 crypto_session_id_t session_id, crypto_object_id_t object,
3870 crypto_object_attribute_t *template, uint_t attribute_count,
3871 crypto_req_handle_t req)
3872 {
3873 int error = CRYPTO_FAILED;
3874 dprov_state_t *softc = (dprov_state_t *)provider;
3875 /* LINTED E_FUNC_SET_NOT_USED */
3876 int instance;
3877
3878 instance = ddi_get_instance(softc->ds_dip);
3879 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_set_attribute_value: "
3880 "started\n", instance));
3881
3882 /* submit request to the taskq */
3883 error = dprov_object_submit_req(DPROV_REQ_OBJECT_SET_ATTRIBUTE_VALUE,
3884 softc, req, session_id, object, template, attribute_count,
3885 NULL, NULL, NULL, NULL, 0, NULL, KM_NOSLEEP);
3886
3887 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_set_attribute_value: "
3888 "done err = 0x0%x\n", instance, error));
3889
3890 return (error);
3891 }
3892
3893 static int
3894 dprov_object_find_init(crypto_provider_handle_t provider,
3895 crypto_session_id_t session_id, crypto_object_attribute_t *template,
3896 uint_t attribute_count, void **provider_private,
3897 crypto_req_handle_t req)
3898 {
3899 int error = CRYPTO_FAILED;
3900 dprov_state_t *softc = (dprov_state_t *)provider;
3901 /* LINTED E_FUNC_SET_NOT_USED */
3902 int instance;
3903
3904 instance = ddi_get_instance(softc->ds_dip);
3905 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_find_init: started\n",
3906 instance));
3907
3908 /* submit request to the taskq */
3909 error = dprov_object_submit_req(DPROV_REQ_OBJECT_FIND_INIT, softc, req,
3910 session_id, 0, template, attribute_count, NULL, NULL,
3911 provider_private, NULL, 0, NULL, KM_SLEEP);
3912
3913 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_find_init: done "
3914 "err = 0x0%x\n", instance, error));
3915
3916 return (error);
3917 }
3918
3919 static int
3920 dprov_object_find(crypto_provider_handle_t provider, void *provider_private,
3921 crypto_object_id_t *objects, uint_t max_object_count,
3922 uint_t *object_count, crypto_req_handle_t req)
3923 {
3924 int error = CRYPTO_FAILED;
3925 dprov_state_t *softc = (dprov_state_t *)provider;
3926 /* LINTED E_FUNC_SET_NOT_USED */
3927 int instance;
3928
3929 instance = ddi_get_instance(softc->ds_dip);
3930 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_find: started\n",
3931 instance));
3932
3933 /* submit request to the taskq */
3934 error = dprov_object_submit_req(DPROV_REQ_OBJECT_FIND, softc, req,
3935 0, 0, NULL, 0, objects, NULL, NULL, provider_private,
3936 max_object_count, object_count, KM_NOSLEEP);
3937
3938
3939 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_find: done err = 0x0%x\n",
3940 instance, error));
3941
3942 return (error);
3943 }
3944
3945 static int
3946 dprov_object_find_final(crypto_provider_handle_t provider,
3947 void *provider_private, crypto_req_handle_t req)
3948 {
3949 int error = CRYPTO_FAILED;
3950 dprov_state_t *softc = (dprov_state_t *)provider;
3951 /* LINTED E_FUNC_SET_NOT_USED */
3952 int instance;
3953
3954 instance = ddi_get_instance(softc->ds_dip);
3955 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_find_final: started\n",
3956 instance));
3957
3958 /* submit request to the taskq */
3959 error = dprov_object_submit_req(DPROV_REQ_OBJECT_FIND_FINAL, softc, req,
3960 0, 0, NULL, 0, NULL, NULL, NULL, provider_private,
3961 0, NULL, KM_NOSLEEP);
3962
3963 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_find_final: done "
3964 "err = 0x0%x\n", instance, error));
3965
3966 return (error);
3967 }
3968
3969 /*
3970 * Key management entry points.
3971 */
3972
3973 static int
3974 dprov_key_generate(crypto_provider_handle_t provider,
3975 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
3976 crypto_object_attribute_t *template, uint_t attribute_count,
3977 crypto_object_id_t *object, crypto_req_handle_t req)
3978 {
3979 int error = CRYPTO_FAILED;
3980 dprov_state_t *softc = (dprov_state_t *)provider;
3981 /* LINTED E_FUNC_SET_NOT_USED */
3982 int instance;
3983
3984 instance = ddi_get_instance(softc->ds_dip);
3985 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_generate: started\n",
3986 instance));
3987
3988 /* submit request to the taskq */
3989 error = dprov_key_submit_req(DPROV_REQ_KEY_GENERATE, softc, req,
3990 session_id, mechanism, template, attribute_count, object, NULL,
3991 0, NULL, NULL, NULL, 0, NULL, 0, NULL, 0);
3992
3993 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_generate: done err = 0x0%x\n",
3994 instance, error));
3995
3996 return (error);
3997 }
3998
3999 static int
4000 dprov_key_generate_pair(crypto_provider_handle_t provider,
4001 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
4002 crypto_object_attribute_t *public_key_template,
4003 uint_t public_key_attribute_count,
4004 crypto_object_attribute_t *private_key_template,
4005 uint_t private_key_attribute_count,
4006 crypto_object_id_t *public_key, crypto_object_id_t *private_key,
4007 crypto_req_handle_t req)
4008 {
4009 int error = CRYPTO_FAILED;
4010 dprov_state_t *softc = (dprov_state_t *)provider;
4011 /* LINTED E_FUNC_SET_NOT_USED */
4012 int instance;
4013
4014 instance = ddi_get_instance(softc->ds_dip);
4015 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_generate_pair: started\n",
4016 instance));
4017
4018 /* submit request to the taskq */
4019 error = dprov_key_submit_req(DPROV_REQ_KEY_GENERATE_PAIR, softc, req,
4020 session_id, mechanism, public_key_template,
4021 public_key_attribute_count, public_key, private_key_template,
4022 private_key_attribute_count, private_key, NULL, NULL, 0, NULL, 0,
4023 NULL, 0);
4024
4025 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_generate_pair: done err = 0x0%x\n",
4026 instance, error));
4027
4028 return (error);
4029 }
4030
4031 static int
4032 dprov_key_wrap(crypto_provider_handle_t provider,
4033 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
4034 crypto_key_t *wrapping_key, crypto_object_id_t *key,
4035 uchar_t *wrapped_key, size_t *wrapped_key_len_ptr, crypto_req_handle_t req)
4036 {
4037 int error = CRYPTO_FAILED;
4038 dprov_state_t *softc = (dprov_state_t *)provider;
4039 /* LINTED E_FUNC_SET_NOT_USED */
4040 int instance;
4041
4042 instance = ddi_get_instance(softc->ds_dip);
4043 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_wrap: started\n",
4044 instance));
4045
4046 /* submit request to the taskq */
4047 error = dprov_key_submit_req(DPROV_REQ_KEY_WRAP, softc, req,
4048 session_id, mechanism, NULL, 0, key, NULL,
4049 0, NULL, wrapping_key, wrapped_key, wrapped_key_len_ptr,
4050 NULL, 0, NULL, 0);
4051
4052 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_wrap: done err = 0x0%x\n",
4053 instance, error));
4054
4055 return (error);
4056 }
4057
4058 static int
4059 dprov_key_unwrap(crypto_provider_handle_t provider,
4060 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
4061 crypto_key_t *unwrapping_key, uchar_t *wrapped_key,
4062 size_t *wrapped_key_len_ptr, crypto_object_attribute_t *template,
4063 uint_t attribute_count, crypto_object_id_t *key, crypto_req_handle_t req)
4064 {
4065 int error = CRYPTO_FAILED;
4066 dprov_state_t *softc = (dprov_state_t *)provider;
4067 /* LINTED E_FUNC_SET_NOT_USED */
4068 int instance;
4069
4070 instance = ddi_get_instance(softc->ds_dip);
4071 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_unwrap: started\n",
4072 instance));
4073
4074 /* submit request to the taskq */
4075 error = dprov_key_submit_req(DPROV_REQ_KEY_UNWRAP, softc, req,
4076 session_id, mechanism, template, attribute_count, key, NULL,
4077 0, NULL, unwrapping_key, wrapped_key, wrapped_key_len_ptr,
4078 NULL, 0, NULL, 0);
4079
4080 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_unwrap: done err = 0x0%x\n",
4081 instance, error));
4082
4083 return (error);
4084 }
4085
4086 static int
4087 dprov_key_derive(crypto_provider_handle_t provider,
4088 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
4089 crypto_key_t *base_key, crypto_object_attribute_t *template,
4090 uint_t attribute_count, crypto_object_id_t *key, crypto_req_handle_t req)
4091 {
4092 int error = CRYPTO_FAILED;
4093 dprov_state_t *softc = (dprov_state_t *)provider;
4094 /* LINTED E_FUNC_SET_NOT_USED */
4095 int instance;
4096
4097 instance = ddi_get_instance(softc->ds_dip);
4098 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_derive: started\n",
4099 instance));
4100
4101 /* submit request to the taskq */
4102 error = dprov_key_submit_req(DPROV_REQ_KEY_DERIVE, softc, req,
4103 session_id, mechanism, template, attribute_count, key, NULL,
4104 0, NULL, base_key, NULL, 0, NULL, 0, NULL, 0);
4105
4106 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_derive: done err = 0x0%x\n",
4107 instance, error));
4108
4109 return (error);
4110 }
4111
4112 /*
4113 * Provider management entry points.
4114 */
4115
4116 static int
4117 dprov_ext_info(crypto_provider_handle_t provider,
4118 crypto_provider_ext_info_t *ext_info, crypto_req_handle_t req)
4119 {
4120 int error = CRYPTO_FAILED;
4121 dprov_state_t *softc = (dprov_state_t *)provider;
4122 /* LINTED E_FUNC_SET_NOT_USED */
4123 int instance;
4124
4125 instance = ddi_get_instance(softc->ds_dip);
4126 DPROV_DEBUG(D_MGMT, ("(%d) dprov_ext_info: started\n",
4127 instance));
4128
4129 error = dprov_mgmt_submit_req(DPROV_REQ_MGMT_EXTINFO, softc, req,
4130 0, NULL, 0, NULL, 0, NULL, ext_info);
4131
4132 DPROV_DEBUG(D_MGMT, ("(%d) dprov_ext_info: done err = 0x0%x\n",
4133 instance, error));
4134
4135 return (error);
4136 }
4137
4138 static int
4139 dprov_init_token(crypto_provider_handle_t provider, char *pin, size_t pin_len,
4140 char *label, crypto_req_handle_t req)
4141 {
4142 int error = CRYPTO_FAILED;
4143 dprov_state_t *softc = (dprov_state_t *)provider;
4144 /* LINTED E_FUNC_SET_NOT_USED */
4145 int instance;
4146
4147 instance = ddi_get_instance(softc->ds_dip);
4148 DPROV_DEBUG(D_MGMT, ("(%d) dprov_init_token: started\n",
4149 instance));
4150
4151 error = dprov_mgmt_submit_req(DPROV_REQ_MGMT_INITTOKEN, softc, req,
4152 0, pin, pin_len, NULL, 0, label, NULL);
4153
4154 DPROV_DEBUG(D_MGMT, ("(%d) dprov_init_token: done err = 0x0%x\n",
4155 instance, error));
4156
4157 return (error);
4158 }
4159
4160 static int
4161 dprov_init_pin(crypto_provider_handle_t provider,
4162 crypto_session_id_t session_id, char *pin, size_t pin_len,
4163 crypto_req_handle_t req)
4164 {
4165 int error = CRYPTO_FAILED;
4166 dprov_state_t *softc = (dprov_state_t *)provider;
4167 /* LINTED E_FUNC_SET_NOT_USED */
4168 int instance;
4169
4170 instance = ddi_get_instance(softc->ds_dip);
4171 DPROV_DEBUG(D_MGMT, ("(%d) dprov_init_pin: started\n",
4172 instance));
4173
4174 error = dprov_mgmt_submit_req(DPROV_REQ_MGMT_INITPIN, softc, req,
4175 session_id, pin, pin_len, NULL, 0, NULL, NULL);
4176
4177 DPROV_DEBUG(D_MGMT, ("(%d) dprov_init_pin: done err = 0x0%x\n",
4178 instance, error));
4179
4180 return (error);
4181 }
4182
4183 static int
4184 dprov_set_pin(crypto_provider_handle_t provider, crypto_session_id_t session_id,
4185 char *old_pin, size_t old_pin_len, char *new_pin, size_t new_pin_len,
4186 crypto_req_handle_t req)
4187 {
4188 int error = CRYPTO_FAILED;
4189 dprov_state_t *softc = (dprov_state_t *)provider;
4190 /* LINTED E_FUNC_SET_NOT_USED */
4191 int instance;
4192
4193 instance = ddi_get_instance(softc->ds_dip);
4194 DPROV_DEBUG(D_MGMT, ("(%d) dprov_set_pin: started\n",
4195 instance));
4196
4197 error = dprov_mgmt_submit_req(DPROV_REQ_MGMT_SETPIN, softc, req,
4198 session_id, new_pin, new_pin_len, old_pin, old_pin_len, NULL, NULL);
4199
4200 DPROV_DEBUG(D_MGMT, ("(%d) dprov_set_pin: done err = 0x0%x\n",
4201 instance, error));
4202
4203 return (error);
4204 }
4205
4206
4207 /*
4208 * Context management entry points.
4209 */
4210
4211 /*
4212 * Allocate a dprov-private context based on the specified dprov request.
4213 * For dual cipher/mac requests, the allocated context will
4214 * contain a structure dprov_ctx_dual_t, for other request types,
4215 * it will contain a dprov_ctx_single.
4216 * Returns one of the CRYPTO_ status codes.
4217 */
4218 static int
4219 dprov_alloc_context(dprov_req_type_t req_type, crypto_ctx_t *spi_ctx)
4220 {
4221 dprov_ctx_single_t *dprov_private;
4222
4223 switch (req_type) {
4224 case DPROV_REQ_ENCRYPT_MAC_INIT:
4225 case DPROV_REQ_MAC_DECRYPT_INIT:
4226 dprov_private = kmem_zalloc(sizeof (dprov_ctx_dual_t),
4227 KM_NOSLEEP);
4228 if (dprov_private == NULL)
4229 return (CRYPTO_HOST_MEMORY);
4230 dprov_private->dc_type = DPROV_CTX_DUAL;
4231 break;
4232 default:
4233 dprov_private = kmem_zalloc(sizeof (dprov_ctx_single_t),
4234 KM_NOSLEEP);
4235 if (dprov_private == NULL)
4236 return (CRYPTO_HOST_MEMORY);
4237 dprov_private->dc_type = DPROV_CTX_SINGLE;
4238 dprov_private->dc_svrfy_to_mac = B_FALSE;
4239 break;
4240 }
4241
4242 spi_ctx->cc_provider_private = (void *)dprov_private;
4243
4244 return (CRYPTO_SUCCESS);
4245 }
4246
4247 static int
4248 dprov_free_context(crypto_ctx_t *ctx)
4249 {
4250 if (ctx->cc_provider_private == NULL)
4251 return (CRYPTO_SUCCESS);
4252
4253 DPROV_DEBUG(D_CONTEXT, ("dprov_free_context\n"));
4254
4255 {
4256 /*
4257 * The dprov private context could contain either
4258 * a dprov_ctx_single_t or a dprov_ctx_dual_t. Free
4259 * the context based on its type. The k-API contexts
4260 * that were attached to the dprov private context
4261 * are freed by the framework.
4262 */
4263 dprov_ctx_single_t *ctx_single =
4264 (dprov_ctx_single_t *)(ctx->cc_provider_private);
4265
4266 if (ctx_single->dc_type == DPROV_CTX_SINGLE) {
4267 crypto_context_t context = DPROV_CTX_SINGLE(ctx);
4268
4269 /*
4270 * This case happens for the crypto_cancel_ctx() case.
4271 * We have to cancel the SW provider context also.
4272 */
4273 if (context != NULL)
4274 crypto_cancel_ctx(context);
4275
4276 kmem_free(ctx_single, sizeof (dprov_ctx_single_t));
4277 } else {
4278 crypto_context_t cipher_context =
4279 DPROV_CTX_DUAL_CIPHER(ctx);
4280 crypto_context_t mac_context = DPROV_CTX_DUAL_MAC(ctx);
4281
4282 /* See comments above. */
4283 if (cipher_context != NULL)
4284 crypto_cancel_ctx(cipher_context);
4285 if (mac_context != NULL)
4286 crypto_cancel_ctx(mac_context);
4287
4288 ASSERT(ctx_single->dc_type == DPROV_CTX_DUAL);
4289 kmem_free(ctx_single, sizeof (dprov_ctx_dual_t));
4290 }
4291 ctx->cc_provider_private = NULL;
4292 }
4293
4294 return (CRYPTO_SUCCESS);
4295 }
4296
4297 /*
4298 * Resource control checks don't need to be done. Why? Because this routine
4299 * knows the size of the structure, and it can't be overridden by a user.
4300 * This is different from the crypto module, which has no knowledge of
4301 * specific mechanisms, and therefore has to trust specified size of the
4302 * parameter. This trust, or lack of trust, is why the size of the
4303 * parameter has to be charged against the project resource control.
4304 */
4305 static int
4306 copyin_aes_ccm_mech(crypto_mechanism_t *in_mech, crypto_mechanism_t *out_mech,
4307 int *out_error, int mode)
4308 {
4309 STRUCT_DECL(crypto_mechanism, mech);
4310 STRUCT_DECL(CK_AES_CCM_PARAMS, params);
4311 CK_AES_CCM_PARAMS *aes_ccm_params;
4312 caddr_t pp;
4313 size_t param_len;
4314 int error = 0;
4315 int rv = 0;
4316
4317 STRUCT_INIT(mech, mode);
4318 STRUCT_INIT(params, mode);
4319 bcopy(in_mech, STRUCT_BUF(mech), STRUCT_SIZE(mech));
4320 pp = STRUCT_FGETP(mech, cm_param);
4321 param_len = STRUCT_FGET(mech, cm_param_len);
4322
4323 if (param_len != STRUCT_SIZE(params)) {
4324 rv = CRYPTO_ARGUMENTS_BAD;
4325 goto out;
4326 }
4327
4328 out_mech->cm_type = STRUCT_FGET(mech, cm_type);
4329 out_mech->cm_param = NULL;
4330 out_mech->cm_param_len = 0;
4331 if (pp != NULL) {
4332 size_t nonce_len, auth_data_len, total_param_len;
4333
4334 if (copyin((char *)pp, STRUCT_BUF(params), param_len) != 0) {
4335 out_mech->cm_param = NULL;
4336 error = EFAULT;
4337 goto out;
4338 }
4339
4340 nonce_len = STRUCT_FGET(params, ulNonceSize);
4341 auth_data_len = STRUCT_FGET(params, ulAuthDataSize);
4342
4343 /* allocate param structure */
4344 total_param_len =
4345 sizeof (CK_AES_CCM_PARAMS) + nonce_len + auth_data_len;
4346 aes_ccm_params = kmem_alloc(total_param_len, KM_NOSLEEP);
4347 if (aes_ccm_params == NULL) {
4348 rv = CRYPTO_HOST_MEMORY;
4349 goto out;
4350 }
4351 aes_ccm_params->ulMACSize = STRUCT_FGET(params, ulMACSize);
4352 aes_ccm_params->ulNonceSize = nonce_len;
4353 aes_ccm_params->ulAuthDataSize = auth_data_len;
4354 aes_ccm_params->ulDataSize
4355 = STRUCT_FGET(params, ulDataSize);
4356 aes_ccm_params->nonce
4357 = (uchar_t *)aes_ccm_params + sizeof (CK_AES_CCM_PARAMS);
4358 aes_ccm_params->authData
4359 = aes_ccm_params->nonce + nonce_len;
4360
4361 if (copyin((char *)STRUCT_FGETP(params, nonce),
4362 aes_ccm_params->nonce, nonce_len) != 0) {
4363 kmem_free(aes_ccm_params, total_param_len);
4364 out_mech->cm_param = NULL;
4365 error = EFAULT;
4366 goto out;
4367 }
4368 if (copyin((char *)STRUCT_FGETP(params, authData),
4369 aes_ccm_params->authData, auth_data_len) != 0) {
4370 kmem_free(aes_ccm_params, total_param_len);
4371 out_mech->cm_param = NULL;
4372 error = EFAULT;
4373 goto out;
4374 }
4375 out_mech->cm_param = (char *)aes_ccm_params;
4376 out_mech->cm_param_len = sizeof (CK_AES_CCM_PARAMS);
4377 }
4378 out:
4379 *out_error = error;
4380 return (rv);
4381 }
4382
4383 /*
4384 * Resource control checks don't need to be done. Why? Because this routine
4385 * knows the size of the structure, and it can't be overridden by a user.
4386 * This is different from the crypto module, which has no knowledge of
4387 * specific mechanisms, and therefore has to trust specified size of the
4388 * parameter. This trust, or lack of trust, is why the size of the
4389 * parameter has to be charged against the project resource control.
4390 */
4391 static int
4392 copyin_aes_gcm_mech(crypto_mechanism_t *in_mech, crypto_mechanism_t *out_mech,
4393 int *out_error, int mode)
4394 {
4395 STRUCT_DECL(crypto_mechanism, mech);
4396 STRUCT_DECL(CK_AES_GCM_PARAMS, params);
4397 CK_AES_GCM_PARAMS *aes_gcm_params;
4398 caddr_t pp;
4399 size_t param_len;
4400 int error = 0;
4401 int rv = 0;
4402
4403 STRUCT_INIT(mech, mode);
4404 STRUCT_INIT(params, mode);
4405 bcopy(in_mech, STRUCT_BUF(mech), STRUCT_SIZE(mech));
4406 pp = STRUCT_FGETP(mech, cm_param);
4407 param_len = STRUCT_FGET(mech, cm_param_len);
4408
4409 if (param_len != STRUCT_SIZE(params)) {
4410 rv = CRYPTO_ARGUMENTS_BAD;
4411 goto out;
4412 }
4413
4414 out_mech->cm_type = STRUCT_FGET(mech, cm_type);
4415 out_mech->cm_param = NULL;
4416 out_mech->cm_param_len = 0;
4417 if (pp != NULL) {
4418 size_t nonce_len, auth_data_len, total_param_len;
4419
4420 if (copyin((char *)pp, STRUCT_BUF(params), param_len) != 0) {
4421 out_mech->cm_param = NULL;
4422 error = EFAULT;
4423 goto out;
4424 }
4425
4426 nonce_len = STRUCT_FGET(params, ulIvLen);
4427 auth_data_len = STRUCT_FGET(params, ulAADLen);
4428
4429 /* allocate param structure */
4430 total_param_len =
4431 sizeof (CK_AES_GCM_PARAMS) + nonce_len + auth_data_len;
4432 aes_gcm_params = kmem_alloc(total_param_len, KM_NOSLEEP);
4433 if (aes_gcm_params == NULL) {
4434 rv = CRYPTO_HOST_MEMORY;
4435 goto out;
4436 }
4437 aes_gcm_params->ulTagBits = STRUCT_FGET(params, ulTagBits);
4438 aes_gcm_params->ulIvLen = nonce_len;
4439 aes_gcm_params->ulAADLen = auth_data_len;
4440 aes_gcm_params->pIv
4441 = (uchar_t *)aes_gcm_params + sizeof (CK_AES_GCM_PARAMS);
4442 aes_gcm_params->pAAD = aes_gcm_params->pIv + nonce_len;
4443
4444 if (copyin((char *)STRUCT_FGETP(params, pIv),
4445 aes_gcm_params->pIv, nonce_len) != 0) {
4446 kmem_free(aes_gcm_params, total_param_len);
4447 out_mech->cm_param = NULL;
4448 error = EFAULT;
4449 goto out;
4450 }
4451 if (copyin((char *)STRUCT_FGETP(params, pAAD),
4452 aes_gcm_params->pAAD, auth_data_len) != 0) {
4453 kmem_free(aes_gcm_params, total_param_len);
4454 out_mech->cm_param = NULL;
4455 error = EFAULT;
4456 goto out;
4457 }
4458 out_mech->cm_param = (char *)aes_gcm_params;
4459 out_mech->cm_param_len = sizeof (CK_AES_GCM_PARAMS);
4460 }
4461 out:
4462 *out_error = error;
4463 return (rv);
4464 }
4465
4466 static int
4467 copyin_aes_gmac_mech(crypto_mechanism_t *in_mech, crypto_mechanism_t *out_mech,
4468 int *out_error, int mode)
4469 {
4470 STRUCT_DECL(crypto_mechanism, mech);
4471 STRUCT_DECL(CK_AES_GMAC_PARAMS, params);
4472 CK_AES_GMAC_PARAMS *aes_gmac_params;
4473 caddr_t pp;
4474 size_t param_len;
4475 int error = 0;
4476 int rv = 0;
4477
4478 STRUCT_INIT(mech, mode);
4479 STRUCT_INIT(params, mode);
4480 bcopy(in_mech, STRUCT_BUF(mech), STRUCT_SIZE(mech));
4481 pp = STRUCT_FGETP(mech, cm_param);
4482 param_len = STRUCT_FGET(mech, cm_param_len);
4483
4484 if (param_len != STRUCT_SIZE(params)) {
4485 rv = CRYPTO_ARGUMENTS_BAD;
4486 goto out;
4487 }
4488
4489 out_mech->cm_type = STRUCT_FGET(mech, cm_type);
4490 out_mech->cm_param = NULL;
4491 out_mech->cm_param_len = 0;
4492 if (pp != NULL) {
4493 size_t auth_data_len, total_param_len;
4494
4495 if (copyin((char *)pp, STRUCT_BUF(params), param_len) != 0) {
4496 out_mech->cm_param = NULL;
4497 error = EFAULT;
4498 goto out;
4499 }
4500
4501 auth_data_len = STRUCT_FGET(params, ulAADLen);
4502
4503 /* allocate param structure */
4504 total_param_len = sizeof (CK_AES_GMAC_PARAMS) +
4505 AES_GMAC_IV_LEN + auth_data_len;
4506 aes_gmac_params = kmem_alloc(total_param_len, KM_NOSLEEP);
4507 if (aes_gmac_params == NULL) {
4508 rv = CRYPTO_HOST_MEMORY;
4509 goto out;
4510 }
4511 aes_gmac_params->ulAADLen = auth_data_len;
4512 aes_gmac_params->pIv
4513 = (uchar_t *)aes_gmac_params + sizeof (CK_AES_GMAC_PARAMS);
4514 aes_gmac_params->pAAD = aes_gmac_params->pIv + AES_GMAC_IV_LEN;
4515
4516 if (copyin((char *)STRUCT_FGETP(params, pIv),
4517 aes_gmac_params->pIv, AES_GMAC_IV_LEN) != 0) {
4518 kmem_free(aes_gmac_params, total_param_len);
4519 out_mech->cm_param = NULL;
4520 error = EFAULT;
4521 goto out;
4522 }
4523 if (copyin((char *)STRUCT_FGETP(params, pAAD),
4524 aes_gmac_params->pAAD, auth_data_len) != 0) {
4525 kmem_free(aes_gmac_params, total_param_len);
4526 out_mech->cm_param = NULL;
4527 error = EFAULT;
4528 goto out;
4529 }
4530 out_mech->cm_param = (char *)aes_gmac_params;
4531 out_mech->cm_param_len = sizeof (CK_AES_GMAC_PARAMS);
4532 }
4533 out:
4534 *out_error = error;
4535 return (rv);
4536 }
4537
4538 /*
4539 * Resource control checks don't need to be done. Why? Because this routine
4540 * knows the size of the structure, and it can't be overridden by a user.
4541 * This is different from the crypto module, which has no knowledge of
4542 * specific mechanisms, and therefore has to trust specified size of the
4543 * parameter. This trust, or lack of trust, is why the size of the
4544 * parameter has to be charged against the project resource control.
4545 */
4546 static int
4547 copyin_aes_ctr_mech(crypto_mechanism_t *in_mech, crypto_mechanism_t *out_mech,
4548 int *out_error, int mode)
4549 {
4550 STRUCT_DECL(crypto_mechanism, mech);
4551 STRUCT_DECL(CK_AES_CTR_PARAMS, params);
4552 CK_AES_CTR_PARAMS *aes_ctr_params;
4553 caddr_t pp;
4554 size_t param_len;
4555 int error = 0;
4556 int rv = 0;
4557
4558 STRUCT_INIT(mech, mode);
4559 STRUCT_INIT(params, mode);
4560 bcopy(in_mech, STRUCT_BUF(mech), STRUCT_SIZE(mech));
4561 pp = STRUCT_FGETP(mech, cm_param);
4562 param_len = STRUCT_FGET(mech, cm_param_len);
4563
4564 if (param_len != STRUCT_SIZE(params)) {
4565 rv = CRYPTO_ARGUMENTS_BAD;
4566 goto out;
4567 }
4568
4569 out_mech->cm_type = STRUCT_FGET(mech, cm_type);
4570 out_mech->cm_param = NULL;
4571 out_mech->cm_param_len = 0;
4572 if (pp != NULL) {
4573 if (copyin((char *)pp, STRUCT_BUF(params), param_len) != 0) {
4574 out_mech->cm_param = NULL;
4575 error = EFAULT;
4576 goto out;
4577 }
4578 /* allocate param structure and counter block */
4579 aes_ctr_params = kmem_alloc(sizeof (CK_AES_CTR_PARAMS),
4580 KM_NOSLEEP);
4581 if (aes_ctr_params == NULL) {
4582 rv = CRYPTO_HOST_MEMORY;
4583 goto out;
4584 }
4585 aes_ctr_params->ulCounterBits = STRUCT_FGET(params,
4586 ulCounterBits);
4587 bcopy(STRUCT_FGETP(params, cb), aes_ctr_params->cb, 16);
4588 out_mech->cm_param = (char *)aes_ctr_params;
4589 out_mech->cm_param_len = sizeof (CK_AES_CTR_PARAMS);
4590 }
4591 out:
4592 *out_error = error;
4593 return (rv);
4594 }
4595
4596 static int
4597 copyin_ecc_mech(crypto_mechanism_t *in_mech, crypto_mechanism_t *out_mech,
4598 int *out_error, int mode)
4599 {
4600 STRUCT_DECL(crypto_mechanism, mech);
4601 STRUCT_DECL(CK_ECDH1_DERIVE_PARAMS, params);
4602 CK_ECDH1_DERIVE_PARAMS *ecc_params;
4603 caddr_t pp;
4604 size_t param_len, shared_data_len, public_data_len;
4605 int error = 0;
4606 int rv = 0;
4607
4608 STRUCT_INIT(mech, mode);
4609 STRUCT_INIT(params, mode);
4610 bcopy(in_mech, STRUCT_BUF(mech), STRUCT_SIZE(mech));
4611 pp = STRUCT_FGETP(mech, cm_param);
4612 param_len = STRUCT_FGET(mech, cm_param_len);
4613
4614 if (param_len != STRUCT_SIZE(params)) {
4615 rv = CRYPTO_ARGUMENTS_BAD;
4616 goto out;
4617 }
4618
4619 out_mech->cm_type = STRUCT_FGET(mech, cm_type);
4620 out_mech->cm_param = NULL;
4621 out_mech->cm_param_len = 0;
4622 if (pp != NULL) {
4623 if (copyin((char *)pp, STRUCT_BUF(params), param_len) != 0) {
4624 out_mech->cm_param = NULL;
4625 error = EFAULT;
4626 goto out;
4627 }
4628 shared_data_len = STRUCT_FGET(params, ulSharedDataLen);
4629 public_data_len = STRUCT_FGET(params, ulPublicDataLen);
4630 /* allocate param structure and buffers */
4631 ecc_params = kmem_alloc(sizeof (CK_ECDH1_DERIVE_PARAMS) +
4632 roundup(shared_data_len, sizeof (caddr_t)) +
4633 roundup(public_data_len, sizeof (caddr_t)), KM_NOSLEEP);
4634 if (ecc_params == NULL) {
4635 rv = CRYPTO_HOST_MEMORY;
4636 goto out;
4637 }
4638 ecc_params->pSharedData = (uchar_t *)ecc_params +
4639 sizeof (CK_ECDH1_DERIVE_PARAMS);
4640 ecc_params->pPublicData = (uchar_t *)ecc_params->pSharedData +
4641 roundup(shared_data_len, sizeof (caddr_t));
4642 if (copyin((char *)STRUCT_FGETP(params, pSharedData),
4643 ecc_params->pSharedData, shared_data_len) != 0) {
4644 kmem_free(ecc_params, sizeof (CK_ECDH1_DERIVE_PARAMS) +
4645 roundup(shared_data_len, sizeof (caddr_t)) +
4646 roundup(public_data_len, sizeof (caddr_t)));
4647 out_mech->cm_param = NULL;
4648 error = EFAULT;
4649 goto out;
4650 }
4651 ecc_params->ulSharedDataLen = shared_data_len;
4652
4653 if (copyin((char *)STRUCT_FGETP(params, pPublicData),
4654 ecc_params->pPublicData, public_data_len) != 0) {
4655 kmem_free(ecc_params, sizeof (CK_ECDH1_DERIVE_PARAMS) +
4656 roundup(shared_data_len, sizeof (caddr_t)) +
4657 roundup(public_data_len, sizeof (caddr_t)));
4658 out_mech->cm_param = NULL;
4659 error = EFAULT;
4660 goto out;
4661 }
4662 ecc_params->ulPublicDataLen = public_data_len;
4663 ecc_params->kdf = STRUCT_FGET(params, kdf);
4664 out_mech->cm_param = (char *)ecc_params;
4665 out_mech->cm_param_len = sizeof (CK_ECDH1_DERIVE_PARAMS);
4666 }
4667 out:
4668 *out_error = error;
4669 return (rv);
4670 }
4671
4672 /* ARGSUSED */
4673 static int
4674 copyout_aes_ctr_mech(crypto_mechanism_t *in_mech, crypto_mechanism_t *out_mech,
4675 int *out_error, int mode)
4676 {
4677 STRUCT_DECL(crypto_mechanism, mech);
4678 STRUCT_DECL(CK_AES_CTR_PARAMS, params);
4679 caddr_t pp;
4680 size_t param_len;
4681 int error = 0;
4682 int rv = 0;
4683
4684 STRUCT_INIT(mech, mode);
4685 STRUCT_INIT(params, mode);
4686 bcopy(out_mech, STRUCT_BUF(mech), STRUCT_SIZE(mech));
4687 pp = STRUCT_FGETP(mech, cm_param);
4688 param_len = STRUCT_FGET(mech, cm_param_len);
4689 if (param_len != STRUCT_SIZE(params)) {
4690 rv = CRYPTO_ARGUMENTS_BAD;
4691 goto out;
4692 }
4693
4694 if (copyin((char *)pp, STRUCT_BUF(params), param_len) != 0) {
4695 error = EFAULT;
4696 goto out;
4697 }
4698
4699 /* for testing, overwrite the iv with 16 X 'A' */
4700 (void) memset(STRUCT_FGETP(params, cb), 'A', 16);
4701 if (copyout((char *)pp, STRUCT_BUF(params), param_len) != 0) {
4702 error = EFAULT;
4703 goto out;
4704 }
4705 out:
4706 *out_error = error;
4707 return (rv);
4708 }
4709
4710 /* ARGSUSED */
4711 static int
4712 dprov_copyin_mechanism(crypto_provider_handle_t provider,
4713 crypto_mechanism_t *umech, crypto_mechanism_t *kmech,
4714 int *out_error, int mode)
4715 {
4716 STRUCT_DECL(crypto_mechanism, mech);
4717 size_t param_len, expected_param_len;
4718 caddr_t pp;
4719 char *param;
4720 int rv;
4721 int error = 0;
4722
4723 ASSERT(!servicing_interrupt());
4724
4725 STRUCT_INIT(mech, mode);
4726 bcopy(umech, STRUCT_BUF(mech), STRUCT_SIZE(mech));
4727 pp = STRUCT_FGETP(mech, cm_param);
4728 param_len = STRUCT_FGET(mech, cm_param_len);
4729
4730 kmech->cm_param = NULL;
4731 kmech->cm_param_len = 0;
4732
4733 switch (kmech->cm_type) {
4734 case DES_CBC_MECH_INFO_TYPE:
4735 case DES3_CBC_MECH_INFO_TYPE:
4736 expected_param_len = DES_BLOCK_LEN;
4737 break;
4738
4739 case BLOWFISH_CBC_MECH_INFO_TYPE:
4740 expected_param_len = BLOWFISH_BLOCK_LEN;
4741 break;
4742
4743 case AES_CBC_MECH_INFO_TYPE:
4744 expected_param_len = AES_BLOCK_LEN;
4745 break;
4746
4747 case AES_CTR_MECH_INFO_TYPE:
4748 case SHA1_KEY_DERIVATION_MECH_INFO_TYPE: /* for testing only */
4749 rv = copyin_aes_ctr_mech(umech, kmech, &error, mode);
4750 goto out;
4751
4752 case ECDH1_DERIVE_MECH_INFO_TYPE:
4753 rv = copyin_ecc_mech(umech, kmech, &error, mode);
4754 goto out;
4755
4756 case AES_CCM_MECH_INFO_TYPE:
4757 rv = copyin_aes_ccm_mech(umech, kmech, &error, mode);
4758 goto out;
4759
4760 case AES_GCM_MECH_INFO_TYPE:
4761 rv = copyin_aes_gcm_mech(umech, kmech, &error, mode);
4762 goto out;
4763
4764 case AES_GMAC_MECH_INFO_TYPE:
4765 rv = copyin_aes_gmac_mech(umech, kmech, &error, mode);
4766 goto out;
4767
4768 case DH_PKCS_DERIVE_MECH_INFO_TYPE:
4769 expected_param_len = param_len;
4770 break;
4771
4772 default:
4773 /* nothing to do - mechanism has no parameters */
4774 rv = CRYPTO_SUCCESS;
4775 goto out;
4776 }
4777
4778 if (param_len != expected_param_len) {
4779 rv = CRYPTO_MECHANISM_PARAM_INVALID;
4780 goto out;
4781 }
4782 if (pp == NULL) {
4783 rv = CRYPTO_MECHANISM_PARAM_INVALID;
4784 goto out;
4785 }
4786 if ((param = kmem_alloc(param_len, KM_NOSLEEP)) == NULL) {
4787 rv = CRYPTO_HOST_MEMORY;
4788 goto out;
4789 }
4790 if (copyin((char *)pp, param, param_len) != 0) {
4791 kmem_free(param, param_len);
4792 error = EFAULT;
4793 rv = CRYPTO_FAILED;
4794 goto out;
4795 }
4796 kmech->cm_param = (char *)param;
4797 kmech->cm_param_len = param_len;
4798 rv = CRYPTO_SUCCESS;
4799 out:
4800 *out_error = error;
4801 return (rv);
4802 }
4803
4804 /* ARGSUSED */
4805 static int
4806 dprov_copyout_mechanism(crypto_provider_handle_t provider,
4807 crypto_mechanism_t *kmech, crypto_mechanism_t *umech,
4808 int *out_error, int mode)
4809 {
4810 ASSERT(!servicing_interrupt());
4811
4812 switch (kmech->cm_type) {
4813 case AES_CTR_MECH_INFO_TYPE:
4814 case SHA1_KEY_DERIVATION_MECH_INFO_TYPE: /* for testing only */
4815 return (copyout_aes_ctr_mech(kmech, umech, out_error, mode));
4816 case ECDH1_DERIVE_MECH_INFO_TYPE:
4817 return (CRYPTO_SUCCESS);
4818 default:
4819 return (CRYPTO_MECHANISM_INVALID);
4820 }
4821 }
4822
4823 /*
4824 * Free mechanism parameter that was allocated by the provider.
4825 */
4826 /* ARGSUSED */
4827 static int
4828 dprov_free_mechanism(crypto_provider_handle_t provider,
4829 crypto_mechanism_t *mech)
4830 {
4831 size_t len;
4832
4833 if (mech->cm_param == NULL || mech->cm_param_len == 0)
4834 return (CRYPTO_SUCCESS);
4835
4836 switch (mech->cm_type) {
4837 case AES_CTR_MECH_INFO_TYPE:
4838 case SHA1_KEY_DERIVATION_MECH_INFO_TYPE:
4839 len = sizeof (CK_AES_CTR_PARAMS);
4840 break;
4841 case ECDH1_DERIVE_MECH_INFO_TYPE: {
4842 CK_ECDH1_DERIVE_PARAMS *ecc_params;
4843
4844 /* LINTED: pointer alignment */
4845 ecc_params = (CK_ECDH1_DERIVE_PARAMS *)mech->cm_param;
4846 kmem_free(ecc_params, sizeof (CK_ECDH1_DERIVE_PARAMS) +
4847 roundup(ecc_params->ulSharedDataLen, sizeof (caddr_t)) +
4848 roundup(ecc_params->ulPublicDataLen, sizeof (caddr_t)));
4849 return (CRYPTO_SUCCESS);
4850 }
4851 case AES_CCM_MECH_INFO_TYPE: {
4852 CK_AES_CCM_PARAMS *params;
4853 size_t total_param_len;
4854
4855 if ((mech->cm_param != NULL) && (mech->cm_param_len != 0)) {
4856 /* LINTED: pointer alignment */
4857 params = (CK_AES_CCM_PARAMS *)mech->cm_param;
4858 total_param_len = mech->cm_param_len +
4859 params->ulNonceSize + params->ulAuthDataSize;
4860 kmem_free(params, total_param_len);
4861 mech->cm_param = NULL;
4862 mech->cm_param_len = 0;
4863 }
4864 return (CRYPTO_SUCCESS);
4865 }
4866 case AES_GMAC_MECH_INFO_TYPE: {
4867 CK_AES_GMAC_PARAMS *params;
4868 size_t total_param_len;
4869
4870 if ((mech->cm_param != NULL) && (mech->cm_param_len != 0)) {
4871 /* LINTED: pointer alignment */
4872 params = (CK_AES_GMAC_PARAMS *)mech->cm_param;
4873 total_param_len = mech->cm_param_len +
4874 AES_GMAC_IV_LEN + params->ulAADLen;
4875 kmem_free(params, total_param_len);
4876 mech->cm_param = NULL;
4877 mech->cm_param_len = 0;
4878 }
4879 return (CRYPTO_SUCCESS);
4880 }
4881 case AES_GCM_MECH_INFO_TYPE: {
4882 CK_AES_GCM_PARAMS *params;
4883 size_t total_param_len;
4884
4885 if ((mech->cm_param != NULL) && (mech->cm_param_len != 0)) {
4886 /* LINTED: pointer alignment */
4887 params = (CK_AES_GCM_PARAMS *)mech->cm_param;
4888 total_param_len = mech->cm_param_len +
4889 params->ulIvLen + params->ulAADLen;
4890 kmem_free(params, total_param_len);
4891 mech->cm_param = NULL;
4892 mech->cm_param_len = 0;
4893 }
4894 return (CRYPTO_SUCCESS);
4895 }
4896
4897 default:
4898 len = mech->cm_param_len;
4899 }
4900 kmem_free(mech->cm_param, len);
4901 return (CRYPTO_SUCCESS);
4902 }
4903
4904 /*
4905 * No (Key)Store Key management entry point.
4906 */
4907 static int
4908 dprov_nostore_key_generate(crypto_provider_handle_t provider,
4909 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
4910 crypto_object_attribute_t *template, uint_t attribute_count,
4911 crypto_object_attribute_t *out_template, uint_t out_attribute_count,
4912 crypto_req_handle_t req)
4913 {
4914 int error = CRYPTO_FAILED;
4915 dprov_state_t *softc = (dprov_state_t *)provider;
4916 /* LINTED E_FUNC_SET_NOT_USED */
4917 int instance;
4918
4919 instance = ddi_get_instance(softc->ds_dip);
4920 DPROV_DEBUG(D_KEY, ("(%d) dprov_nostore_key_generate: started\n",
4921 instance));
4922
4923 /* submit request to the taskq */
4924 error = dprov_key_submit_req(DPROV_REQ_NOSTORE_KEY_GENERATE,
4925 softc, req, session_id, mechanism, template, attribute_count,
4926 NULL, NULL, 0, NULL, NULL, NULL, 0, out_template,
4927 out_attribute_count, NULL, 0);
4928
4929 DPROV_DEBUG(D_KEY, ("(%d) dprov_nostore_key_generate: "
4930 "done err = 0x0%x\n", instance, error));
4931
4932 return (error);
4933 }
4934
4935 static int
4936 dprov_nostore_key_generate_pair(crypto_provider_handle_t provider,
4937 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
4938 crypto_object_attribute_t *public_key_template,
4939 uint_t public_key_attribute_count,
4940 crypto_object_attribute_t *private_key_template,
4941 uint_t private_key_attribute_count,
4942 crypto_object_attribute_t *out_public_key_template,
4943 uint_t out_public_key_attribute_count,
4944 crypto_object_attribute_t *out_private_key_template,
4945 uint_t out_private_key_attribute_count,
4946 crypto_req_handle_t req)
4947 {
4948 int error = CRYPTO_FAILED;
4949 dprov_state_t *softc = (dprov_state_t *)provider;
4950 /* LINTED E_FUNC_SET_NOT_USED */
4951 int instance;
4952
4953 instance = ddi_get_instance(softc->ds_dip);
4954 DPROV_DEBUG(D_KEY, ("(%d) dprov_nostore_key_generate_pair: started\n",
4955 instance));
4956
4957 /* submit request to the taskq */
4958 error = dprov_key_submit_req(DPROV_REQ_NOSTORE_KEY_GENERATE_PAIR,
4959 softc, req, session_id, mechanism, public_key_template,
4960 public_key_attribute_count, NULL, private_key_template,
4961 private_key_attribute_count, NULL, NULL, NULL, 0,
4962 out_public_key_template, out_public_key_attribute_count,
4963 out_private_key_template, out_private_key_attribute_count);
4964
4965 DPROV_DEBUG(D_KEY, ("(%d) dprov_nostore_key_generate_pair: "
4966 "done err = 0x0%x\n", instance, error));
4967
4968 return (error);
4969 }
4970
4971 static int
4972 dprov_nostore_key_derive(crypto_provider_handle_t provider,
4973 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
4974 crypto_key_t *base_key, crypto_object_attribute_t *template,
4975 uint_t attribute_count, crypto_object_attribute_t *out_template,
4976 uint_t out_attribute_count, crypto_req_handle_t req)
4977 {
4978 int error = CRYPTO_FAILED;
4979 dprov_state_t *softc = (dprov_state_t *)provider;
4980 /* LINTED E_FUNC_SET_NOT_USED */
4981 int instance;
4982
4983 instance = ddi_get_instance(softc->ds_dip);
4984 DPROV_DEBUG(D_KEY, ("(%d) dprov_nostore_key_derive: started\n",
4985 instance));
4986
4987 /* submit request to the taskq */
4988 error = dprov_key_submit_req(DPROV_REQ_NOSTORE_KEY_DERIVE, softc, req,
4989 session_id, mechanism, template, attribute_count, NULL, NULL,
4990 0, NULL, base_key, NULL, 0, out_template, out_attribute_count,
4991 NULL, 0);
4992
4993 DPROV_DEBUG(D_KEY, ("(%d) dprov_nostore_key_derive: "
4994 "done err = 0x0%x\n", instance, error));
4995
4996 return (error);
4997 }
4998
4999 /*
5000 * Allocate a dprov taskq request and initialize the common fields.
5001 * Return NULL if the memory allocation failed.
5002 */
5003 static dprov_req_t *
5004 dprov_alloc_req(dprov_req_type_t req_type, dprov_state_t *softc,
5005 crypto_req_handle_t kcf_req, int kmflag)
5006 {
5007 dprov_req_t *taskq_req;
5008
5009 if ((taskq_req = kmem_alloc(sizeof (dprov_req_t), kmflag)) == NULL)
5010 return (NULL);
5011
5012 taskq_req->dr_type = req_type;
5013 taskq_req->dr_softc = softc;
5014 taskq_req->dr_kcf_req = kcf_req;
5015
5016 return (taskq_req);
5017 }
5018
5019 /*
5020 * Dispatch a dprov request on the taskq associated with a softc.
5021 * Returns CRYPTO_HOST_MEMORY if the request cannot be queued,
5022 * CRYPTO_QUEUED on success.
5023 */
5024 static int
5025 dprov_taskq_dispatch(dprov_state_t *softc, dprov_req_t *taskq_req,
5026 task_func_t *func, int kmflag)
5027 {
5028 if (taskq_dispatch(softc->ds_taskq, func, taskq_req,
5029 kmflag == KM_NOSLEEP ? TQ_NOSLEEP : TQ_SLEEP) == (taskqid_t)0) {
5030 kmem_free(taskq_req, sizeof (dprov_req_t));
5031 return (CRYPTO_HOST_MEMORY);
5032 } else
5033 return (CRYPTO_QUEUED);
5034 }
5035
5036 /*
5037 * Helper function to submit digest operations to the taskq.
5038 * Returns one of the CRYPTO_ errors.
5039 */
5040 static int
5041 dprov_digest_submit_req(dprov_req_type_t req_type,
5042 dprov_state_t *softc, crypto_req_handle_t req,
5043 crypto_mechanism_t *mechanism, crypto_data_t *data, crypto_key_t *key,
5044 crypto_data_t *digest, crypto_ctx_t *ctx, int kmflag)
5045 {
5046 dprov_req_t *taskq_req;
5047
5048 if ((taskq_req = dprov_alloc_req(req_type, softc, req, kmflag)) == NULL)
5049 return (CRYPTO_HOST_MEMORY);
5050
5051 taskq_req->dr_digest_req.dr_mechanism = mechanism;
5052 taskq_req->dr_digest_req.dr_ctx = ctx;
5053 taskq_req->dr_digest_req.dr_data = data;
5054 taskq_req->dr_digest_req.dr_key = key;
5055 taskq_req->dr_digest_req.dr_digest = digest;
5056
5057 return (dprov_taskq_dispatch(softc, taskq_req,
5058 (task_func_t *)dprov_digest_task, kmflag));
5059 }
5060
5061 /*
5062 * Helper function to submit mac operations to the taskq.
5063 * Returns one of the CRYPTO_ errors.
5064 */
5065 static int
5066 dprov_mac_submit_req(dprov_req_type_t req_type,
5067 dprov_state_t *softc, crypto_req_handle_t req,
5068 crypto_mechanism_t *mechanism, crypto_data_t *data, crypto_key_t *key,
5069 crypto_data_t *mac, crypto_ctx_t *ctx, crypto_session_id_t sid, int kmflag)
5070 {
5071 dprov_req_t *taskq_req;
5072
5073 if ((taskq_req = dprov_alloc_req(req_type, softc, req, kmflag)) == NULL)
5074 return (CRYPTO_HOST_MEMORY);
5075
5076 taskq_req->dr_mac_req.dr_mechanism = mechanism;
5077 taskq_req->dr_mac_req.dr_ctx = ctx;
5078 taskq_req->dr_mac_req.dr_data = data;
5079 taskq_req->dr_mac_req.dr_key = key;
5080 taskq_req->dr_mac_req.dr_mac = mac;
5081 taskq_req->dr_mac_req.dr_session_id = sid;
5082
5083 return (dprov_taskq_dispatch(softc, taskq_req,
5084 (task_func_t *)dprov_mac_task, kmflag));
5085 }
5086
5087 /*
5088 * Helper function to submit sign operations to the taskq.
5089 * Returns one of the CRYPTO_ errors.
5090 */
5091 static int
5092 dprov_sign_submit_req(dprov_req_type_t req_type,
5093 dprov_state_t *softc, crypto_req_handle_t req,
5094 crypto_mechanism_t *mechanism, crypto_key_t *key, crypto_data_t *data,
5095 crypto_data_t *signature, crypto_ctx_t *ctx, crypto_session_id_t sid,
5096 int kmflag)
5097 {
5098 dprov_req_t *taskq_req;
5099
5100 if ((taskq_req = dprov_alloc_req(req_type, softc, req, kmflag)) == NULL)
5101 return (CRYPTO_HOST_MEMORY);
5102
5103 taskq_req->dr_sign_req.sr_mechanism = mechanism;
5104 taskq_req->dr_sign_req.sr_ctx = ctx;
5105 taskq_req->dr_sign_req.sr_key = key;
5106 taskq_req->dr_sign_req.sr_data = data;
5107 taskq_req->dr_sign_req.sr_signature = signature;
5108 taskq_req->dr_sign_req.sr_session_id = sid;
5109
5110 return (dprov_taskq_dispatch(softc, taskq_req,
5111 (task_func_t *)dprov_sign_task, kmflag));
5112 }
5113
5114 /*
5115 * Helper function to submit verify operations to the taskq.
5116 * Returns one of the CRYPTO_ errors.
5117 */
5118 static int
5119 dprov_verify_submit_req(dprov_req_type_t req_type,
5120 dprov_state_t *softc, crypto_req_handle_t req,
5121 crypto_mechanism_t *mechanism, crypto_key_t *key, crypto_data_t *data,
5122 crypto_data_t *signature, crypto_ctx_t *ctx, crypto_session_id_t sid,
5123 int kmflag)
5124 {
5125 dprov_req_t *taskq_req;
5126
5127 if ((taskq_req = dprov_alloc_req(req_type, softc, req, kmflag)) == NULL)
5128 return (CRYPTO_HOST_MEMORY);
5129
5130 taskq_req->dr_verify_req.vr_mechanism = mechanism;
5131 taskq_req->dr_verify_req.vr_ctx = ctx;
5132 taskq_req->dr_verify_req.vr_key = key;
5133 taskq_req->dr_verify_req.vr_data = data;
5134 taskq_req->dr_verify_req.vr_signature = signature;
5135 taskq_req->dr_verify_req.vr_session_id = sid;
5136
5137 return (dprov_taskq_dispatch(softc, taskq_req,
5138 (task_func_t *)dprov_verify_task, kmflag));
5139 }
5140
5141 /*
5142 * Helper function to submit dual operations to the taskq.
5143 * Returns one of the CRYPTO_ errors.
5144 */
5145 static int
5146 dprov_dual_submit_req(dprov_req_type_t req_type, dprov_state_t *softc,
5147 crypto_req_handle_t req, crypto_ctx_t *signverify_ctx,
5148 crypto_ctx_t *cipher_ctx, crypto_data_t *plaintext,
5149 crypto_data_t *ciphertext)
5150 {
5151 dprov_req_t *taskq_req;
5152
5153 if ((taskq_req = dprov_alloc_req(req_type, softc, req,
5154 KM_NOSLEEP)) == NULL)
5155 return (CRYPTO_HOST_MEMORY);
5156
5157 taskq_req->dr_dual_req.dr_signverify_ctx = signverify_ctx;
5158 taskq_req->dr_dual_req.dr_cipher_ctx = cipher_ctx;
5159 taskq_req->dr_dual_req.dr_plaintext = plaintext;
5160 taskq_req->dr_dual_req.dr_ciphertext = ciphertext;
5161
5162 return (dprov_taskq_dispatch(softc, taskq_req,
5163 (task_func_t *)dprov_dual_task, KM_NOSLEEP));
5164 }
5165
5166 /*
5167 * Helper function to submit dual cipher/mac operations to the taskq.
5168 * Returns one of the CRYPTO_ errors.
5169 */
5170 static int
5171 dprov_cipher_mac_submit_req(dprov_req_type_t req_type,
5172 dprov_state_t *softc, crypto_req_handle_t req, crypto_ctx_t *ctx,
5173 crypto_session_id_t sid, crypto_mechanism_t *cipher_mech,
5174 crypto_key_t *cipher_key, crypto_mechanism_t *mac_mech,
5175 crypto_key_t *mac_key, crypto_dual_data_t *dual_data,
5176 crypto_data_t *data, crypto_data_t *mac, int kmflag)
5177 {
5178 dprov_req_t *taskq_req;
5179
5180 if ((taskq_req = dprov_alloc_req(req_type, softc, req, kmflag)) == NULL)
5181 return (CRYPTO_HOST_MEMORY);
5182
5183 taskq_req->dr_cipher_mac_req.mr_session_id = sid;
5184 taskq_req->dr_cipher_mac_req.mr_ctx = ctx;
5185 taskq_req->dr_cipher_mac_req.mr_cipher_mech = cipher_mech;
5186 taskq_req->dr_cipher_mac_req.mr_cipher_key = cipher_key;
5187 taskq_req->dr_cipher_mac_req.mr_mac_mech = mac_mech;
5188 taskq_req->dr_cipher_mac_req.mr_mac_key = mac_key;
5189 taskq_req->dr_cipher_mac_req.mr_dual_data = dual_data;
5190 taskq_req->dr_cipher_mac_req.mr_data = data;
5191 taskq_req->dr_cipher_mac_req.mr_mac = mac;
5192
5193 return (dprov_taskq_dispatch(softc, taskq_req,
5194 (task_func_t *)dprov_cipher_mac_task, kmflag));
5195 }
5196
5197 /*
5198 * Helper function to submit cipher operations to the taskq.
5199 * Returns one of the CRYPTO_ errors.
5200 */
5201 static int
5202 dprov_cipher_submit_req(dprov_req_type_t req_type,
5203 dprov_state_t *softc, crypto_req_handle_t req,
5204 crypto_mechanism_t *mechanism, crypto_key_t *key, crypto_data_t *plaintext,
5205 crypto_data_t *ciphertext, crypto_ctx_t *ctx, crypto_session_id_t sid,
5206 int kmflag)
5207 {
5208 dprov_req_t *taskq_req;
5209
5210 if ((taskq_req = dprov_alloc_req(req_type, softc, req, kmflag)) == NULL)
5211 return (CRYPTO_HOST_MEMORY);
5212
5213 taskq_req->dr_cipher_req.dr_mechanism = mechanism;
5214 taskq_req->dr_cipher_req.dr_ctx = ctx;
5215 taskq_req->dr_cipher_req.dr_key = key;
5216 taskq_req->dr_cipher_req.dr_plaintext = plaintext;
5217 taskq_req->dr_cipher_req.dr_ciphertext = ciphertext;
5218 taskq_req->dr_cipher_req.dr_session_id = sid;
5219
5220 return (dprov_taskq_dispatch(softc, taskq_req,
5221 (task_func_t *)dprov_cipher_task, kmflag));
5222 }
5223
5224 /*
5225 * Helper function to submit random number operations to the taskq.
5226 * Returns one of the CRYPTO_ errors.
5227 */
5228 static int
5229 dprov_random_submit_req(dprov_req_type_t req_type,
5230 dprov_state_t *softc, crypto_req_handle_t req, uchar_t *buf, size_t len,
5231 crypto_session_id_t sid, uint_t entropy_est, uint32_t flags)
5232 {
5233 dprov_req_t *taskq_req;
5234
5235 if ((taskq_req = dprov_alloc_req(req_type, softc, req,
5236 KM_NOSLEEP)) == NULL)
5237 return (CRYPTO_HOST_MEMORY);
5238
5239 taskq_req->dr_random_req.rr_buf = buf;
5240 taskq_req->dr_random_req.rr_len = len;
5241 taskq_req->dr_random_req.rr_session_id = sid;
5242 taskq_req->dr_random_req.rr_entropy_est = entropy_est;
5243 taskq_req->dr_random_req.rr_flags = flags;
5244
5245 return (dprov_taskq_dispatch(softc, taskq_req,
5246 (task_func_t *)dprov_random_task, KM_NOSLEEP));
5247 }
5248
5249
5250 /*
5251 * Helper function to submit session management operations to the taskq.
5252 * Returns one of the CRYPTO_ errors.
5253 */
5254 static int
5255 dprov_session_submit_req(dprov_req_type_t req_type,
5256 dprov_state_t *softc, crypto_req_handle_t req,
5257 crypto_session_id_t *session_id_ptr, crypto_session_id_t session_id,
5258 crypto_user_type_t user_type, char *pin, size_t pin_len)
5259 {
5260 dprov_req_t *taskq_req;
5261
5262 if ((taskq_req = dprov_alloc_req(req_type, softc, req,
5263 KM_NOSLEEP)) == NULL)
5264 return (CRYPTO_HOST_MEMORY);
5265
5266 taskq_req->dr_session_req.sr_session_id_ptr = session_id_ptr;
5267 taskq_req->dr_session_req.sr_session_id = session_id;
5268 taskq_req->dr_session_req.sr_user_type = user_type;
5269 taskq_req->dr_session_req.sr_pin = pin;
5270 taskq_req->dr_session_req.sr_pin_len = pin_len;
5271
5272 return (dprov_taskq_dispatch(softc, taskq_req,
5273 (task_func_t *)dprov_session_task, KM_NOSLEEP));
5274 }
5275
5276 /*
5277 * Helper function to submit object management operations to the taskq.
5278 * Returns one of the CRYPTO_ errors.
5279 */
5280 static int
5281 dprov_object_submit_req(dprov_req_type_t req_type,
5282 dprov_state_t *softc, crypto_req_handle_t req,
5283 crypto_session_id_t session_id, crypto_object_id_t object_id,
5284 crypto_object_attribute_t *template, uint_t attribute_count,
5285 crypto_object_id_t *object_id_ptr, size_t *object_size,
5286 void **find_pp, void *find_p, uint_t max_object_count,
5287 uint_t *object_count_ptr, int kmflag)
5288 {
5289 dprov_req_t *taskq_req;
5290
5291 if ((taskq_req = dprov_alloc_req(req_type, softc, req,
5292 kmflag)) == NULL)
5293 return (CRYPTO_HOST_MEMORY);
5294
5295 taskq_req->dr_object_req.or_session_id = session_id;
5296 taskq_req->dr_object_req.or_object_id = object_id;
5297 taskq_req->dr_object_req.or_template = template;
5298 taskq_req->dr_object_req.or_attribute_count = attribute_count;
5299 taskq_req->dr_object_req.or_object_id_ptr = object_id_ptr;
5300 taskq_req->dr_object_req.or_object_size = object_size;
5301 taskq_req->dr_object_req.or_find_pp = find_pp;
5302 taskq_req->dr_object_req.or_find_p = find_p;
5303 taskq_req->dr_object_req.or_max_object_count = max_object_count;
5304 taskq_req->dr_object_req.or_object_count_ptr = object_count_ptr;
5305
5306 return (dprov_taskq_dispatch(softc, taskq_req,
5307 (task_func_t *)dprov_object_task, KM_NOSLEEP));
5308 }
5309
5310 /*
5311 * Helper function to submit key management operations to the taskq.
5312 * Returns one of the CRYPTO_ errors.
5313 */
5314 static int
5315 dprov_key_submit_req(dprov_req_type_t req_type,
5316 dprov_state_t *softc, crypto_req_handle_t req,
5317 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
5318 crypto_object_attribute_t *template, uint_t attribute_count,
5319 crypto_object_id_t *object_id_ptr,
5320 crypto_object_attribute_t *private_key_template,
5321 uint_t private_key_attribute_count,
5322 crypto_object_id_t *private_key_object_id_ptr, crypto_key_t *key,
5323 uchar_t *wrapped_key, size_t *wrapped_key_len_ptr,
5324 crypto_object_attribute_t *out_template1, uint_t out_attribute_count1,
5325 crypto_object_attribute_t *out_template2, uint_t out_attribute_count2)
5326 {
5327 dprov_req_t *taskq_req;
5328
5329 if ((taskq_req = dprov_alloc_req(req_type, softc, req,
5330 KM_NOSLEEP)) == NULL)
5331 return (CRYPTO_HOST_MEMORY);
5332
5333 taskq_req->dr_key_req.kr_session_id = session_id;
5334 taskq_req->dr_key_req.kr_mechanism = mechanism;
5335 taskq_req->dr_key_req.kr_template = template;
5336 taskq_req->dr_key_req.kr_attribute_count = attribute_count;
5337 taskq_req->dr_key_req.kr_object_id_ptr = object_id_ptr;
5338 taskq_req->dr_key_req.kr_private_key_template = private_key_template;
5339 taskq_req->dr_key_req.kr_private_key_attribute_count =
5340 private_key_attribute_count;
5341 taskq_req->dr_key_req.kr_private_key_object_id_ptr =
5342 private_key_object_id_ptr;
5343 taskq_req->dr_key_req.kr_key = key;
5344 taskq_req->dr_key_req.kr_wrapped_key = wrapped_key;
5345 taskq_req->dr_key_req.kr_wrapped_key_len_ptr = wrapped_key_len_ptr;
5346 taskq_req->dr_key_req.kr_out_template1 = out_template1;
5347 taskq_req->dr_key_req.kr_out_attribute_count1 = out_attribute_count1;
5348 taskq_req->dr_key_req.kr_out_template2 = out_template2;
5349 taskq_req->dr_key_req.kr_out_attribute_count2 = out_attribute_count2;
5350
5351 return (dprov_taskq_dispatch(softc, taskq_req,
5352 (task_func_t *)dprov_key_task, KM_NOSLEEP));
5353 }
5354
5355 /*
5356 * Helper function to submit provider management operations to the taskq.
5357 * Returns one of the CRYPTO_ errors.
5358 */
5359 static int
5360 dprov_mgmt_submit_req(dprov_req_type_t req_type,
5361 dprov_state_t *softc, crypto_req_handle_t req,
5362 crypto_session_id_t session_id, char *pin, size_t pin_len,
5363 char *old_pin, size_t old_pin_len, char *label,
5364 crypto_provider_ext_info_t *ext_info)
5365 {
5366 dprov_req_t *taskq_req;
5367
5368 if ((taskq_req = dprov_alloc_req(req_type, softc, req,
5369 KM_NOSLEEP)) == NULL)
5370 return (CRYPTO_HOST_MEMORY);
5371
5372 taskq_req->dr_mgmt_req.mr_session_id = session_id;
5373 taskq_req->dr_mgmt_req.mr_pin = pin;
5374 taskq_req->dr_mgmt_req.mr_pin_len = pin_len;
5375 taskq_req->dr_mgmt_req.mr_old_pin = old_pin;
5376 taskq_req->dr_mgmt_req.mr_old_pin_len = old_pin_len;
5377 taskq_req->dr_mgmt_req.mr_label = label;
5378 taskq_req->dr_mgmt_req.mr_ext_info = ext_info;
5379
5380 return (dprov_taskq_dispatch(softc, taskq_req,
5381 (task_func_t *)dprov_mgmt_task, KM_NOSLEEP));
5382 }
5383
5384 /*
5385 * Helper function for taskq dispatcher routines. Notify the framework
5386 * that the operation corresponding to the specified request is done,
5387 * and pass it the error code. Finally, free the taskq_req.
5388 */
5389 static void
5390 dprov_op_done(dprov_req_t *taskq_req, int error)
5391 {
5392 /* notify framework that request is completed */
5393 crypto_op_notification(taskq_req->dr_kcf_req, error);
5394
5395 /* free taskq request structure */
5396 kmem_free(taskq_req, sizeof (dprov_req_t));
5397 }
5398
5399 /*
5400 * taskq dispatcher function for digest operations.
5401 */
5402 static void
5403 dprov_digest_task(dprov_req_t *taskq_req)
5404 {
5405 kcf_provider_desc_t *pd;
5406 dprov_state_t *softc;
5407 /* LINTED E_FUNC_SET_NOT_USED */
5408 int instance;
5409 int error = CRYPTO_NOT_SUPPORTED;
5410 crypto_ctx_t *ctx = taskq_req->dr_digest_req.dr_ctx;
5411 crypto_mechanism_t mech;
5412
5413 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
5414 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_task: started\n", instance));
5415
5416 switch (taskq_req->dr_type) {
5417
5418 case DPROV_REQ_DIGEST_INIT:
5419 /* allocate a dprov-private context */
5420 if ((error = dprov_alloc_context(taskq_req->dr_type, ctx)) !=
5421 CRYPTO_SUCCESS)
5422 break;
5423
5424 /* structure assignment */
5425 mech = *taskq_req->dr_digest_req.dr_mechanism;
5426
5427 /* get the software provider for this mechanism */
5428 if ((error = dprov_get_sw_prov(
5429 taskq_req->dr_digest_req.dr_mechanism, &pd,
5430 &mech.cm_type)) != CRYPTO_SUCCESS)
5431 break;
5432
5433 /* Use a session id of zero since we use a software provider */
5434 error = crypto_digest_init_prov(pd, 0, &mech,
5435 &DPROV_CTX_SINGLE(ctx), NULL);
5436
5437 /* release provider reference */
5438 KCF_PROV_REFRELE(pd);
5439 break;
5440
5441 case DPROV_REQ_DIGEST:
5442 error = crypto_digest_single(DPROV_CTX_SINGLE(ctx),
5443 taskq_req->dr_digest_req.dr_data,
5444 taskq_req->dr_digest_req.dr_digest, NULL);
5445
5446 if (error != CRYPTO_BUFFER_TOO_SMALL) {
5447 DPROV_CTX_SINGLE(ctx) = NULL;
5448 (void) dprov_free_context(ctx);
5449 }
5450 break;
5451
5452 case DPROV_REQ_DIGEST_UPDATE:
5453 error = crypto_digest_update(DPROV_CTX_SINGLE(ctx),
5454 taskq_req->dr_digest_req.dr_data, NULL);
5455 break;
5456
5457 case DPROV_REQ_DIGEST_KEY: {
5458 crypto_data_t data;
5459 crypto_key_t key;
5460 size_t len;
5461
5462 mutex_enter(&softc->ds_lock);
5463 error = dprov_key_value_secret(softc, ctx->cc_session,
5464 taskq_req->dr_type, taskq_req->dr_digest_req.dr_key, &key);
5465 mutex_exit(&softc->ds_lock);
5466 if (error != CRYPTO_SUCCESS)
5467 break;
5468
5469 /* key lengths are specified in bits */
5470 len = CRYPTO_BITS2BYTES(key.ck_length);
5471 data.cd_format = CRYPTO_DATA_RAW;
5472 data.cd_offset = 0;
5473 data.cd_length = len;
5474 data.cd_raw.iov_base = key.ck_data;
5475 data.cd_raw.iov_len = len;
5476 error = crypto_digest_update(DPROV_CTX_SINGLE(ctx),
5477 &data, NULL);
5478 break;
5479 }
5480
5481 case DPROV_REQ_DIGEST_FINAL:
5482 error = crypto_digest_final(DPROV_CTX_SINGLE(ctx),
5483 taskq_req->dr_digest_req.dr_digest, NULL);
5484 if (error != CRYPTO_BUFFER_TOO_SMALL) {
5485 DPROV_CTX_SINGLE(ctx) = NULL;
5486 (void) dprov_free_context(ctx);
5487 }
5488 break;
5489
5490 case DPROV_REQ_DIGEST_ATOMIC:
5491 /* structure assignment */
5492 mech = *taskq_req->dr_digest_req.dr_mechanism;
5493
5494 /* get the software provider for this mechanism */
5495 if ((error = dprov_get_sw_prov(
5496 taskq_req->dr_digest_req.dr_mechanism, &pd,
5497 &mech.cm_type)) != CRYPTO_SUCCESS)
5498 break;
5499
5500 /* use a session id of zero since we use a software provider */
5501 error = crypto_digest_prov(pd, 0, &mech,
5502 taskq_req->dr_digest_req.dr_data,
5503 taskq_req->dr_digest_req.dr_digest, NULL);
5504
5505 /* release provider reference */
5506 KCF_PROV_REFRELE(pd);
5507
5508 break;
5509 }
5510
5511 dprov_op_done(taskq_req, error);
5512 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_digest_task: end\n", instance));
5513 }
5514
5515 /*
5516 * taskq dispatcher function for mac operations.
5517 */
5518 static void
5519 dprov_mac_task(dprov_req_t *taskq_req)
5520 {
5521 kcf_provider_desc_t *pd;
5522 dprov_state_t *softc;
5523 /* LINTED E_FUNC_SET_NOT_USED */
5524 int instance;
5525 int error = CRYPTO_NOT_SUPPORTED;
5526 crypto_ctx_t *ctx = taskq_req->dr_mac_req.dr_ctx;
5527 crypto_key_t key;
5528 crypto_mechanism_t mech;
5529
5530 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
5531 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_task: started\n", instance));
5532
5533 switch (taskq_req->dr_type) {
5534
5535 case DPROV_REQ_MAC_INIT:
5536 /* allocate a dprov-private context */
5537 if ((error = dprov_alloc_context(taskq_req->dr_type, ctx)) !=
5538 CRYPTO_SUCCESS)
5539 break;
5540
5541 /* get key value */
5542 mutex_enter(&softc->ds_lock);
5543 error = dprov_key_value_secret(softc, ctx->cc_session,
5544 taskq_req->dr_type, taskq_req->dr_mac_req.dr_key, &key);
5545 mutex_exit(&softc->ds_lock);
5546 if (error != CRYPTO_SUCCESS)
5547 break;
5548
5549 /* structure assignment */
5550 mech = *taskq_req->dr_mac_req.dr_mechanism;
5551
5552 /* get the software provider for this mechanism */
5553 if ((error = dprov_get_sw_prov(
5554 taskq_req->dr_mac_req.dr_mechanism, &pd,
5555 &mech.cm_type)) != CRYPTO_SUCCESS)
5556 break;
5557
5558 /* Use a session id of zero since we use a software provider */
5559 error = crypto_mac_init_prov(pd, 0, &mech, &key, NULL,
5560 &DPROV_CTX_SINGLE(ctx), NULL);
5561
5562 /* release provider reference */
5563 KCF_PROV_REFRELE(pd);
5564 break;
5565
5566 case DPROV_REQ_MAC:
5567 error = crypto_mac_single(DPROV_CTX_SINGLE(ctx),
5568 taskq_req->dr_mac_req.dr_data,
5569 taskq_req->dr_mac_req.dr_mac, NULL);
5570
5571 if (error != CRYPTO_BUFFER_TOO_SMALL) {
5572 DPROV_CTX_SINGLE(ctx) = NULL;
5573 (void) dprov_free_context(ctx);
5574 }
5575 break;
5576
5577 case DPROV_REQ_MAC_UPDATE:
5578 error = crypto_mac_update(DPROV_CTX_SINGLE(ctx),
5579 taskq_req->dr_mac_req.dr_data, NULL);
5580 break;
5581
5582 case DPROV_REQ_MAC_FINAL:
5583 error = crypto_mac_final(DPROV_CTX_SINGLE(ctx),
5584 taskq_req->dr_mac_req.dr_mac, NULL);
5585 if (error != CRYPTO_BUFFER_TOO_SMALL) {
5586 DPROV_CTX_SINGLE(ctx) = NULL;
5587 (void) dprov_free_context(ctx);
5588 }
5589 break;
5590
5591 case DPROV_REQ_MAC_ATOMIC:
5592 case DPROV_REQ_MAC_VERIFY_ATOMIC:
5593 /* get key value */
5594 mutex_enter(&softc->ds_lock);
5595 error = dprov_key_value_secret(softc,
5596 taskq_req->dr_mac_req.dr_session_id,
5597 taskq_req->dr_type, taskq_req->dr_mac_req.dr_key, &key);
5598 mutex_exit(&softc->ds_lock);
5599 if (error != CRYPTO_SUCCESS)
5600 break;
5601
5602 /* structure assignment */
5603 mech = *taskq_req->dr_mac_req.dr_mechanism;
5604
5605 /* get the software provider for this mechanism */
5606 if ((error = dprov_get_sw_prov(
5607 taskq_req->dr_mac_req.dr_mechanism, &pd,
5608 &mech.cm_type)) != CRYPTO_SUCCESS)
5609 break;
5610
5611 /* use a session id of zero since we use a software provider */
5612 if (taskq_req->dr_type == DPROV_REQ_MAC_ATOMIC)
5613 error = crypto_mac_prov(pd, 0, &mech,
5614 taskq_req->dr_mac_req.dr_data,
5615 &key, NULL, taskq_req->dr_mac_req.dr_mac, NULL);
5616 else
5617 error = crypto_mac_verify_prov(pd, 0, &mech,
5618 taskq_req->dr_mac_req.dr_data,
5619 &key, NULL, taskq_req->dr_mac_req.dr_mac, NULL);
5620
5621 /* release provider reference */
5622 KCF_PROV_REFRELE(pd);
5623
5624 break;
5625 }
5626
5627 dprov_op_done(taskq_req, error);
5628 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_task: end\n", instance));
5629 }
5630
5631 /*
5632 * taskq dispatcher function for sign operations.
5633 */
5634 static void
5635 dprov_sign_task(dprov_req_t *taskq_req)
5636 {
5637 kcf_provider_desc_t *pd;
5638 dprov_state_t *softc;
5639 /* LINTED E_FUNC_SET_NOT_USED */
5640 int instance;
5641 int error = CRYPTO_NOT_SUPPORTED;
5642 crypto_ctx_t *ctx = taskq_req->dr_sign_req.sr_ctx;
5643 crypto_key_t key, *keyp;
5644 crypto_mechanism_t mech;
5645
5646 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
5647 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_task: started\n", instance));
5648
5649 switch (taskq_req->dr_type) {
5650
5651 case DPROV_REQ_SIGN_INIT:
5652 case DPROV_REQ_SIGN_RECOVER_INIT:
5653 /* allocate a dprov-private context */
5654 if ((error = dprov_alloc_context(taskq_req->dr_type, ctx)) !=
5655 CRYPTO_SUCCESS)
5656 break;
5657
5658 /* structure assignment */
5659 mech = *taskq_req->dr_sign_req.sr_mechanism;
5660 if (dprov_valid_mac_mech(mech.cm_type)) {
5661 DPROV_CTX_P(ctx)->dc_svrfy_to_mac = B_TRUE;
5662 }
5663
5664 mutex_enter(&softc->ds_lock);
5665 if (is_publickey_mech(mech.cm_type)) {
5666 if ((error = dprov_key_attr_asymmetric(softc,
5667 ctx->cc_session, taskq_req->dr_type,
5668 taskq_req->dr_sign_req.sr_key, &key))
5669 != CRYPTO_SUCCESS) {
5670 mutex_exit(&softc->ds_lock);
5671 break;
5672 }
5673 keyp = &key;
5674 } else {
5675 if ((error = dprov_key_value_secret(softc,
5676 ctx->cc_session, taskq_req->dr_type,
5677 taskq_req->dr_sign_req.sr_key, &key))
5678 != CRYPTO_SUCCESS) {
5679 mutex_exit(&softc->ds_lock);
5680 break;
5681 }
5682 keyp = &key;
5683 }
5684 mutex_exit(&softc->ds_lock);
5685
5686 /* get the software provider for this mechanism */
5687 if ((error = dprov_get_sw_prov(
5688 taskq_req->dr_sign_req.sr_mechanism, &pd,
5689 &mech.cm_type)) != CRYPTO_SUCCESS)
5690 break;
5691
5692 if (DPROV_CTX_P(ctx)->dc_svrfy_to_mac) {
5693 error = crypto_mac_init_prov(pd, 0, &mech, keyp, NULL,
5694 &DPROV_CTX_SINGLE(ctx), NULL);
5695
5696 /* release provider reference */
5697 KCF_PROV_REFRELE(pd);
5698 break;
5699 }
5700
5701 /* Use a session id of zero since we use a software provider */
5702 if (taskq_req->dr_type == DPROV_REQ_SIGN_INIT)
5703 error = crypto_sign_init_prov(pd, 0, &mech, keyp,
5704 NULL, &DPROV_CTX_SINGLE(ctx), NULL);
5705 else
5706 error = crypto_sign_recover_init_prov(pd, 0, &mech,
5707 keyp, NULL, &DPROV_CTX_SINGLE(ctx), NULL);
5708
5709 /* release provider reference */
5710 KCF_PROV_REFRELE(pd);
5711
5712 break;
5713
5714 case DPROV_REQ_SIGN:
5715 if (DPROV_CTX_P(ctx)->dc_svrfy_to_mac) {
5716 /* Emulate using update and final */
5717 error = crypto_mac_update(DPROV_CTX_SINGLE(ctx),
5718 taskq_req->dr_mac_req.dr_data, NULL);
5719 if (error == CRYPTO_SUCCESS) {
5720 error = crypto_mac_final(DPROV_CTX_SINGLE(ctx),
5721 taskq_req->dr_mac_req.dr_mac, NULL);
5722 }
5723 } else {
5724 error = crypto_sign_single(DPROV_CTX_SINGLE(ctx),
5725 taskq_req->dr_sign_req.sr_data,
5726 taskq_req->dr_sign_req.sr_signature, NULL);
5727 }
5728
5729 if (error != CRYPTO_BUFFER_TOO_SMALL) {
5730 DPROV_CTX_SINGLE(ctx) = NULL;
5731 (void) dprov_free_context(ctx);
5732 }
5733 break;
5734
5735 case DPROV_REQ_SIGN_UPDATE:
5736 if (DPROV_CTX_P(ctx)->dc_svrfy_to_mac) {
5737 error = crypto_mac_update(DPROV_CTX_SINGLE(ctx),
5738 taskq_req->dr_mac_req.dr_data, NULL);
5739 } else {
5740 error = crypto_sign_update(DPROV_CTX_SINGLE(ctx),
5741 taskq_req->dr_sign_req.sr_data, NULL);
5742 }
5743 break;
5744
5745 case DPROV_REQ_SIGN_FINAL:
5746 if (DPROV_CTX_P(ctx)->dc_svrfy_to_mac) {
5747 error = crypto_mac_final(DPROV_CTX_SINGLE(ctx),
5748 taskq_req->dr_mac_req.dr_mac, NULL);
5749 } else {
5750 error = crypto_sign_final(DPROV_CTX_SINGLE(ctx),
5751 taskq_req->dr_sign_req.sr_signature, NULL);
5752 }
5753
5754 if (error != CRYPTO_BUFFER_TOO_SMALL) {
5755 DPROV_CTX_SINGLE(ctx) = NULL;
5756 (void) dprov_free_context(ctx);
5757 }
5758 break;
5759
5760 case DPROV_REQ_SIGN_ATOMIC:
5761 case DPROV_REQ_SIGN_RECOVER_ATOMIC:
5762 /* structure assignment */
5763 mech = *taskq_req->dr_sign_req.sr_mechanism;
5764
5765 mutex_enter(&softc->ds_lock);
5766 /* get key value for secret key algorithms */
5767 if (is_publickey_mech(mech.cm_type)) {
5768 if ((error = dprov_key_attr_asymmetric(softc,
5769 taskq_req->dr_sign_req.sr_session_id,
5770 taskq_req->dr_type,
5771 taskq_req->dr_sign_req.sr_key, &key))
5772 != CRYPTO_SUCCESS) {
5773 mutex_exit(&softc->ds_lock);
5774 break;
5775 }
5776 keyp = &key;
5777 } else {
5778 if ((error = dprov_key_value_secret(softc,
5779 taskq_req->dr_sign_req.sr_session_id,
5780 taskq_req->dr_type,
5781 taskq_req->dr_sign_req.sr_key, &key))
5782 != CRYPTO_SUCCESS) {
5783 mutex_exit(&softc->ds_lock);
5784 break;
5785 }
5786 keyp = &key;
5787 }
5788 mutex_exit(&softc->ds_lock);
5789
5790 /* get the software provider for this mechanism */
5791 if ((error = dprov_get_sw_prov(
5792 taskq_req->dr_sign_req.sr_mechanism, &pd,
5793 &mech.cm_type)) != CRYPTO_SUCCESS)
5794 break;
5795
5796 /* Use a session id of zero since we use a software provider */
5797 if (taskq_req->dr_type == DPROV_REQ_SIGN_ATOMIC)
5798 error = crypto_sign_prov(pd, 0, &mech, keyp,
5799 taskq_req->dr_sign_req.sr_data,
5800 NULL, taskq_req->dr_sign_req.sr_signature, NULL);
5801 else
5802 error = crypto_sign_recover_prov(pd, 0, &mech, keyp,
5803 taskq_req->dr_sign_req.sr_data,
5804 NULL, taskq_req->dr_sign_req.sr_signature, NULL);
5805
5806 /* release provider reference */
5807 KCF_PROV_REFRELE(pd);
5808 break;
5809
5810 case DPROV_REQ_SIGN_RECOVER:
5811 error = crypto_sign_recover_single(DPROV_CTX_SINGLE(ctx),
5812 taskq_req->dr_sign_req.sr_data,
5813 taskq_req->dr_sign_req.sr_signature, NULL);
5814
5815 if (error != CRYPTO_BUFFER_TOO_SMALL) {
5816 DPROV_CTX_SINGLE(ctx) = NULL;
5817 (void) dprov_free_context(ctx);
5818 }
5819 break;
5820 }
5821
5822 dprov_op_done(taskq_req, error);
5823 DPROV_DEBUG(D_SIGN, ("(%d) dprov_sign_task: end\n", instance));
5824 }
5825
5826 static int
5827 emulate_verify_with_mac(crypto_ctx_t *ctx, crypto_data_t *in_mac)
5828 {
5829 int error;
5830 crypto_data_t tmpd;
5831 crypto_data_t *out_mac;
5832 char digest[SHA512_DIGEST_LENGTH];
5833
5834 bzero(&tmpd, sizeof (crypto_data_t));
5835 tmpd.cd_format = CRYPTO_DATA_RAW;
5836 tmpd.cd_length = SHA512_DIGEST_LENGTH;
5837 tmpd.cd_raw.iov_base = digest;
5838 tmpd.cd_raw.iov_len = SHA512_DIGEST_LENGTH;
5839 out_mac = &tmpd;
5840
5841 error = crypto_mac_final(DPROV_CTX_SINGLE(ctx), out_mac, NULL);
5842 if (in_mac->cd_length != out_mac->cd_length ||
5843 (bcmp(digest, (unsigned char *)in_mac->cd_raw.iov_base +
5844 in_mac->cd_offset, out_mac->cd_length) != 0)) {
5845 error = CRYPTO_INVALID_MAC;
5846 }
5847
5848 return (error);
5849 }
5850
5851 /*
5852 * taskq dispatcher function for verify operations.
5853 */
5854 static void
5855 dprov_verify_task(dprov_req_t *taskq_req)
5856 {
5857 kcf_provider_desc_t *pd;
5858 dprov_state_t *softc;
5859 /* LINTED E_FUNC_SET_NOT_USED */
5860 int instance;
5861 int error = CRYPTO_NOT_SUPPORTED;
5862 crypto_ctx_t *ctx = taskq_req->dr_verify_req.vr_ctx;
5863 crypto_key_t key, *keyp;
5864 crypto_mechanism_t mech;
5865
5866 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
5867 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_task: started\n", instance));
5868
5869 switch (taskq_req->dr_type) {
5870
5871 case DPROV_REQ_VERIFY_INIT:
5872 case DPROV_REQ_VERIFY_RECOVER_INIT:
5873 /* allocate a dprov-private context */
5874 if ((error = dprov_alloc_context(taskq_req->dr_type, ctx)) !=
5875 CRYPTO_SUCCESS)
5876 break;
5877
5878 /* structure assignment */
5879 mech = *taskq_req->dr_verify_req.vr_mechanism;
5880 if (dprov_valid_mac_mech(mech.cm_type)) {
5881 DPROV_CTX_P(ctx)->dc_svrfy_to_mac = B_TRUE;
5882 }
5883
5884 mutex_enter(&softc->ds_lock);
5885 /* get key value for secret key algorithms */
5886 if (is_publickey_mech(mech.cm_type)) {
5887 if ((error = dprov_key_attr_asymmetric(softc,
5888 ctx->cc_session, taskq_req->dr_type,
5889 taskq_req->dr_verify_req.vr_key, &key))
5890 != CRYPTO_SUCCESS) {
5891 mutex_exit(&softc->ds_lock);
5892 break;
5893 }
5894 keyp = &key;
5895 } else {
5896 if ((error = dprov_key_value_secret(softc,
5897 ctx->cc_session, taskq_req->dr_type,
5898 taskq_req->dr_verify_req.vr_key, &key))
5899 != CRYPTO_SUCCESS) {
5900 mutex_exit(&softc->ds_lock);
5901 break;
5902 }
5903 keyp = &key;
5904 }
5905 mutex_exit(&softc->ds_lock);
5906
5907 /* get the software provider for this mechanism */
5908 if ((error = dprov_get_sw_prov(
5909 taskq_req->dr_verify_req.vr_mechanism, &pd,
5910 &mech.cm_type)) != CRYPTO_SUCCESS)
5911 break;
5912
5913
5914 if (DPROV_CTX_P(ctx)->dc_svrfy_to_mac) {
5915 error = crypto_mac_init_prov(pd, 0, &mech, keyp, NULL,
5916 &DPROV_CTX_SINGLE(ctx), NULL);
5917
5918 /* release provider reference */
5919 KCF_PROV_REFRELE(pd);
5920 break;
5921 }
5922
5923 /* Use a session id of zero since we use a software provider */
5924 if (taskq_req->dr_type == DPROV_REQ_VERIFY_INIT)
5925 error = crypto_verify_init_prov(pd, 0, &mech, keyp,
5926 NULL, &DPROV_CTX_SINGLE(ctx), NULL);
5927 else
5928 error = crypto_verify_recover_init_prov(pd, 0, &mech,
5929 keyp, NULL, &DPROV_CTX_SINGLE(ctx), NULL);
5930
5931 /* release provider reference */
5932 KCF_PROV_REFRELE(pd);
5933
5934 break;
5935
5936 case DPROV_REQ_VERIFY:
5937 if (DPROV_CTX_P(ctx)->dc_svrfy_to_mac) {
5938 /* Emulate using update and final */
5939 error = crypto_mac_update(DPROV_CTX_SINGLE(ctx),
5940 taskq_req->dr_mac_req.dr_data, NULL);
5941 if (error == CRYPTO_SUCCESS) {
5942 error = emulate_verify_with_mac(ctx,
5943 taskq_req->dr_mac_req.dr_mac);
5944 }
5945 } else {
5946 error = crypto_verify_single(DPROV_CTX_SINGLE(ctx),
5947 taskq_req->dr_verify_req.vr_data,
5948 taskq_req->dr_verify_req.vr_signature, NULL);
5949 }
5950
5951 ASSERT(error != CRYPTO_BUFFER_TOO_SMALL);
5952 DPROV_CTX_SINGLE(ctx) = NULL;
5953 (void) dprov_free_context(ctx);
5954 break;
5955
5956 case DPROV_REQ_VERIFY_UPDATE:
5957 if (DPROV_CTX_P(ctx)->dc_svrfy_to_mac) {
5958 error = crypto_mac_update(DPROV_CTX_SINGLE(ctx),
5959 taskq_req->dr_mac_req.dr_data, NULL);
5960 } else {
5961 error = crypto_verify_update(DPROV_CTX_SINGLE(ctx),
5962 taskq_req->dr_verify_req.vr_data, NULL);
5963 }
5964 break;
5965
5966 case DPROV_REQ_VERIFY_FINAL:
5967 if (DPROV_CTX_P(ctx)->dc_svrfy_to_mac) {
5968 error = emulate_verify_with_mac(ctx,
5969 taskq_req->dr_mac_req.dr_mac);
5970 } else {
5971 error = crypto_verify_final(DPROV_CTX_SINGLE(ctx),
5972 taskq_req->dr_verify_req.vr_signature, NULL);
5973 }
5974
5975 ASSERT(error != CRYPTO_BUFFER_TOO_SMALL);
5976 DPROV_CTX_SINGLE(ctx) = NULL;
5977 (void) dprov_free_context(ctx);
5978 break;
5979
5980 case DPROV_REQ_VERIFY_ATOMIC:
5981 case DPROV_REQ_VERIFY_RECOVER_ATOMIC:
5982 /* structure assignment */
5983 mech = *taskq_req->dr_verify_req.vr_mechanism;
5984
5985 mutex_enter(&softc->ds_lock);
5986 /* get key value for secret key algorithms */
5987 if (is_publickey_mech(mech.cm_type)) {
5988 if ((error = dprov_key_attr_asymmetric(softc,
5989 taskq_req->dr_verify_req.vr_session_id,
5990 taskq_req->dr_type,
5991 taskq_req->dr_verify_req.vr_key, &key))
5992 != CRYPTO_SUCCESS) {
5993 mutex_exit(&softc->ds_lock);
5994 break;
5995 }
5996 keyp = &key;
5997 } else {
5998 if ((error = dprov_key_value_secret(softc,
5999 taskq_req->dr_verify_req.vr_session_id,
6000 taskq_req->dr_type,
6001 taskq_req->dr_verify_req.vr_key, &key))
6002 != CRYPTO_SUCCESS) {
6003 mutex_exit(&softc->ds_lock);
6004 break;
6005 }
6006 keyp = &key;
6007 }
6008 mutex_exit(&softc->ds_lock);
6009
6010 /* get the software provider for this mechanism */
6011 if ((error = dprov_get_sw_prov(
6012 taskq_req->dr_verify_req.vr_mechanism, &pd,
6013 &mech.cm_type)) != CRYPTO_SUCCESS)
6014 break;
6015
6016 /* Use a session id of zero since we use a software provider */
6017 if (taskq_req->dr_type == DPROV_REQ_VERIFY_ATOMIC)
6018 error = crypto_verify_prov(pd, 0, &mech, keyp,
6019 taskq_req->dr_verify_req.vr_data,
6020 NULL, taskq_req->dr_verify_req.vr_signature, NULL);
6021 else
6022 /*
6023 * crypto_verify_recover_prov() has different argument
6024 * order than crypto_verify_prov().
6025 */
6026 error = crypto_verify_recover_prov(pd, 0, &mech, keyp,
6027 taskq_req->dr_verify_req.vr_signature,
6028 NULL, taskq_req->dr_verify_req.vr_data, NULL);
6029
6030 /* release provider reference */
6031 KCF_PROV_REFRELE(pd);
6032 break;
6033
6034 case DPROV_REQ_VERIFY_RECOVER:
6035 /*
6036 * crypto_verify_recover_single() has different argument
6037 * order than crypto_verify_single().
6038 */
6039 error = crypto_verify_recover_single(DPROV_CTX_SINGLE(ctx),
6040 taskq_req->dr_verify_req.vr_signature,
6041 taskq_req->dr_verify_req.vr_data, NULL);
6042
6043 if (error != CRYPTO_BUFFER_TOO_SMALL) {
6044 DPROV_CTX_SINGLE(ctx) = NULL;
6045 (void) dprov_free_context(ctx);
6046 }
6047 break;
6048 }
6049
6050 dprov_op_done(taskq_req, error);
6051 DPROV_DEBUG(D_VERIFY, ("(%d) dprov_verify_task: end\n", instance));
6052 }
6053
6054 /*
6055 * taskq dispatcher function for dual operations.
6056 */
6057 static void
6058 dprov_dual_task(dprov_req_t *taskq_req)
6059 {
6060 dprov_state_t *softc;
6061 /* LINTED E_FUNC_SET_NOT_USED */
6062 int instance;
6063 int error = CRYPTO_NOT_SUPPORTED;
6064 crypto_ctx_t *signverify_ctx = taskq_req->dr_dual_req.dr_signverify_ctx;
6065 crypto_ctx_t *cipher_ctx = taskq_req->dr_dual_req.dr_cipher_ctx;
6066
6067 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
6068 DPROV_DEBUG(D_DUAL, ("(%d) dprov_dual_task: started\n", instance));
6069
6070 switch (taskq_req->dr_type) {
6071
6072 case DPROV_REQ_DIGEST_ENCRYPT_UPDATE:
6073 error = crypto_digest_encrypt_update(
6074 DPROV_CTX_SINGLE(signverify_ctx),
6075 DPROV_CTX_SINGLE(cipher_ctx),
6076 taskq_req->dr_dual_req.dr_plaintext,
6077 taskq_req->dr_dual_req.dr_ciphertext, NULL);
6078 break;
6079
6080 case DPROV_REQ_DECRYPT_DIGEST_UPDATE:
6081 error = crypto_decrypt_digest_update(
6082 DPROV_CTX_SINGLE(cipher_ctx),
6083 DPROV_CTX_SINGLE(signverify_ctx),
6084 taskq_req->dr_dual_req.dr_ciphertext,
6085 taskq_req->dr_dual_req.dr_plaintext, NULL);
6086 break;
6087
6088 case DPROV_REQ_SIGN_ENCRYPT_UPDATE:
6089 error = crypto_sign_encrypt_update(
6090 DPROV_CTX_SINGLE(signverify_ctx),
6091 DPROV_CTX_SINGLE(cipher_ctx),
6092 taskq_req->dr_dual_req.dr_plaintext,
6093 taskq_req->dr_dual_req.dr_ciphertext, NULL);
6094 break;
6095
6096 case DPROV_REQ_DECRYPT_VERIFY_UPDATE:
6097 error = crypto_decrypt_verify_update(
6098 DPROV_CTX_SINGLE(cipher_ctx),
6099 DPROV_CTX_SINGLE(signverify_ctx),
6100 taskq_req->dr_dual_req.dr_ciphertext,
6101 taskq_req->dr_dual_req.dr_plaintext, NULL);
6102 break;
6103 }
6104
6105 dprov_op_done(taskq_req, error);
6106 DPROV_DEBUG(D_DUAL, ("(%d) dprov_dual_task: end\n", instance));
6107 }
6108
6109 /*
6110 * taskq dispatcher function for cipher operations.
6111 */
6112 static void
6113 dprov_cipher_task(dprov_req_t *taskq_req)
6114 {
6115 kcf_provider_desc_t *pd;
6116 dprov_state_t *softc;
6117 /* LINTED E_FUNC_SET_NOT_USED */
6118 int instance;
6119 int error = CRYPTO_NOT_SUPPORTED;
6120 crypto_ctx_t *ctx = taskq_req->dr_cipher_req.dr_ctx;
6121 crypto_key_t key, *keyp;
6122 crypto_mechanism_t mech;
6123
6124 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
6125 DPROV_DEBUG(D_CIPHER, ("(%d) dprov_cipher_task: started\n", instance));
6126
6127 switch (taskq_req->dr_type) {
6128
6129 case DPROV_REQ_ENCRYPT_INIT:
6130 case DPROV_REQ_DECRYPT_INIT:
6131 /* allocate a dprov-private context */
6132 if ((error = dprov_alloc_context(taskq_req->dr_type, ctx)) !=
6133 CRYPTO_SUCCESS)
6134 break;
6135
6136 /* structure assignment */
6137 mech = *taskq_req->dr_cipher_req.dr_mechanism;
6138
6139 mutex_enter(&softc->ds_lock);
6140 /* get key value for secret key algorithms */
6141 if (is_publickey_mech(mech.cm_type)) {
6142 if ((error = dprov_key_attr_asymmetric(softc,
6143 ctx->cc_session, taskq_req->dr_type,
6144 taskq_req->dr_cipher_req.dr_key, &key))
6145 != CRYPTO_SUCCESS) {
6146 mutex_exit(&softc->ds_lock);
6147 break;
6148 }
6149 keyp = &key;
6150 } else {
6151 if ((error = dprov_key_value_secret(softc,
6152 ctx->cc_session, taskq_req->dr_type,
6153 taskq_req->dr_cipher_req.dr_key, &key))
6154 != CRYPTO_SUCCESS) {
6155 mutex_exit(&softc->ds_lock);
6156 break;
6157 }
6158 keyp = &key;
6159 }
6160 mutex_exit(&softc->ds_lock);
6161
6162 /* get the software provider for this mechanism */
6163 if ((error = dprov_get_sw_prov(
6164 taskq_req->dr_cipher_req.dr_mechanism, &pd,
6165 &mech.cm_type)) != CRYPTO_SUCCESS)
6166 break;
6167
6168 /* Use a session id of zero since we use a software provider */
6169 if (taskq_req->dr_type == DPROV_REQ_ENCRYPT_INIT)
6170 error = crypto_encrypt_init_prov(pd, 0, &mech, keyp,
6171 NULL, &DPROV_CTX_SINGLE(ctx), NULL);
6172 else
6173 error = crypto_decrypt_init_prov(pd, 0, &mech, keyp,
6174 NULL, &DPROV_CTX_SINGLE(ctx), NULL);
6175
6176 if (ctx->cc_flags & CRYPTO_INIT_OPSTATE) {
6177 crypto_ctx_t *lctx =
6178 (crypto_ctx_t *)(DPROV_CTX_SINGLE(ctx));
6179
6180 ctx->cc_opstate = lctx->cc_provider_private;
6181 ctx->cc_flags |= CRYPTO_USE_OPSTATE;
6182 }
6183
6184 /* release provider reference */
6185 KCF_PROV_REFRELE(pd);
6186 break;
6187
6188 case DPROV_REQ_ENCRYPT:
6189 error = crypto_encrypt_single(DPROV_CTX_SINGLE(ctx),
6190 taskq_req->dr_cipher_req.dr_plaintext,
6191 taskq_req->dr_cipher_req.dr_ciphertext, NULL);
6192
6193 if (error != CRYPTO_BUFFER_TOO_SMALL) {
6194 DPROV_CTX_SINGLE(ctx) = NULL;
6195 (void) dprov_free_context(ctx);
6196 }
6197 break;
6198
6199 case DPROV_REQ_DECRYPT:
6200 error = crypto_decrypt_single(DPROV_CTX_SINGLE(ctx),
6201 taskq_req->dr_cipher_req.dr_ciphertext,
6202 taskq_req->dr_cipher_req.dr_plaintext, NULL);
6203
6204 if (error != CRYPTO_BUFFER_TOO_SMALL) {
6205 DPROV_CTX_SINGLE(ctx) = NULL;
6206 (void) dprov_free_context(ctx);
6207 }
6208 break;
6209
6210 case DPROV_REQ_ENCRYPT_UPDATE:
6211 ASSERT(!(ctx->cc_flags & CRYPTO_INIT_OPSTATE) ||
6212 (ctx->cc_flags & CRYPTO_USE_OPSTATE));
6213 error = crypto_encrypt_update(DPROV_CTX_SINGLE(ctx),
6214 taskq_req->dr_cipher_req.dr_plaintext,
6215 taskq_req->dr_cipher_req.dr_ciphertext, NULL);
6216 break;
6217
6218 case DPROV_REQ_DECRYPT_UPDATE:
6219 ASSERT(!(ctx->cc_flags & CRYPTO_INIT_OPSTATE) ||
6220 (ctx->cc_flags & CRYPTO_USE_OPSTATE));
6221 error = crypto_decrypt_update(DPROV_CTX_SINGLE(ctx),
6222 taskq_req->dr_cipher_req.dr_ciphertext,
6223 taskq_req->dr_cipher_req.dr_plaintext, NULL);
6224 break;
6225
6226 case DPROV_REQ_ENCRYPT_FINAL:
6227 error = crypto_encrypt_final(DPROV_CTX_SINGLE(ctx),
6228 taskq_req->dr_cipher_req.dr_ciphertext, NULL);
6229 if (error != CRYPTO_BUFFER_TOO_SMALL) {
6230 DPROV_CTX_SINGLE(ctx) = NULL;
6231 (void) dprov_free_context(ctx);
6232 }
6233 break;
6234
6235 case DPROV_REQ_DECRYPT_FINAL:
6236 error = crypto_decrypt_final(DPROV_CTX_SINGLE(ctx),
6237 taskq_req->dr_cipher_req.dr_plaintext, NULL);
6238 if (error != CRYPTO_BUFFER_TOO_SMALL) {
6239 DPROV_CTX_SINGLE(ctx) = NULL;
6240 (void) dprov_free_context(ctx);
6241 }
6242 break;
6243
6244 case DPROV_REQ_ENCRYPT_ATOMIC:
6245 case DPROV_REQ_DECRYPT_ATOMIC:
6246 /* structure assignment */
6247 mech = *taskq_req->dr_cipher_req.dr_mechanism;
6248
6249 mutex_enter(&softc->ds_lock);
6250 /* get key value for secret key algorithms */
6251 if (is_publickey_mech(mech.cm_type)) {
6252 if ((error = dprov_key_attr_asymmetric(softc,
6253 taskq_req->dr_cipher_req.dr_session_id,
6254 taskq_req->dr_type,
6255 taskq_req->dr_cipher_req.dr_key,
6256 &key)) != CRYPTO_SUCCESS) {
6257 mutex_exit(&softc->ds_lock);
6258 break;
6259 }
6260 keyp = &key;
6261 } else {
6262 if ((error = dprov_key_value_secret(softc,
6263 taskq_req->dr_cipher_req.dr_session_id,
6264 taskq_req->dr_type, taskq_req->dr_cipher_req.dr_key,
6265 &key))
6266 != CRYPTO_SUCCESS) {
6267 mutex_exit(&softc->ds_lock);
6268 break;
6269 }
6270 keyp = &key;
6271 }
6272 mutex_exit(&softc->ds_lock);
6273
6274 /* get the software provider for this mechanism */
6275 if ((error = dprov_get_sw_prov(
6276 taskq_req->dr_cipher_req.dr_mechanism, &pd,
6277 &mech.cm_type)) != CRYPTO_SUCCESS)
6278 break;
6279
6280 /* use a session id of zero since we use a software provider */
6281 if (taskq_req->dr_type == DPROV_REQ_ENCRYPT_ATOMIC)
6282 error = crypto_encrypt_prov(pd, 0, &mech,
6283 taskq_req->dr_cipher_req.dr_plaintext,
6284 keyp, NULL,
6285 taskq_req->dr_cipher_req.dr_ciphertext, NULL);
6286 else
6287 error = crypto_decrypt_prov(pd, 0, &mech,
6288 taskq_req->dr_cipher_req.dr_ciphertext,
6289 keyp, NULL,
6290 taskq_req->dr_cipher_req.dr_plaintext, NULL);
6291
6292 /* release provider reference */
6293 KCF_PROV_REFRELE(pd);
6294
6295 break;
6296 }
6297
6298 dprov_op_done(taskq_req, error);
6299 DPROV_DEBUG(D_MAC, ("(%d) dprov_mac_task: end\n", instance));
6300 }
6301
6302 /*
6303 * Helper function for the cipher/mac dual operation taskq dispatch
6304 * function. Initialize the cipher and mac key values and find the
6305 * providers that can process the request for the specified mechanisms.
6306 */
6307 static int
6308 dprov_cipher_mac_key_pd(dprov_state_t *softc, crypto_session_id_t sid,
6309 dprov_req_t *taskq_req, crypto_key_t *cipher_key, crypto_key_t *mac_key,
6310 kcf_provider_desc_t **cipher_pd, kcf_provider_desc_t **mac_pd,
6311 crypto_mech_type_t *cipher_mech_type, crypto_mech_type_t *mac_mech_type)
6312 {
6313 int error;
6314
6315 /* get the cipher key value */
6316 mutex_enter(&softc->ds_lock);
6317 error = dprov_key_value_secret(softc, sid, DPROV_REQ_ENCRYPT_ATOMIC,
6318 taskq_req->dr_cipher_mac_req.mr_cipher_key, cipher_key);
6319 if (error != CRYPTO_SUCCESS) {
6320 mutex_exit(&softc->ds_lock);
6321 return (error);
6322 }
6323
6324 /* get the mac key value */
6325 error = dprov_key_value_secret(softc, sid, DPROV_REQ_MAC_ATOMIC,
6326 taskq_req->dr_cipher_mac_req.mr_mac_key, mac_key);
6327 mutex_exit(&softc->ds_lock);
6328 if (error != CRYPTO_SUCCESS)
6329 return (error);
6330
6331 /* get the SW provider to perform the cipher operation */
6332 if ((error = dprov_get_sw_prov(
6333 taskq_req->dr_cipher_mac_req.mr_cipher_mech, cipher_pd,
6334 cipher_mech_type)) != CRYPTO_SUCCESS)
6335 return (error);
6336
6337 /* get the SW provider to perform the mac operation */
6338 error = dprov_get_sw_prov(taskq_req->dr_cipher_mac_req.mr_mac_mech,
6339 mac_pd, mac_mech_type);
6340
6341 return (error);
6342 }
6343
6344 /*
6345 * taskq dispatcher function for cipher/mac dual operations.
6346 */
6347 static void
6348 dprov_cipher_mac_task(dprov_req_t *taskq_req)
6349 {
6350 dprov_state_t *softc;
6351 /* LINTED E_FUNC_SET_NOT_USED */
6352 int instance;
6353 int error = CRYPTO_NOT_SUPPORTED;
6354 crypto_ctx_t *ctx = taskq_req->dr_cipher_mac_req.mr_ctx;
6355 kcf_provider_desc_t *cipher_pd;
6356 kcf_provider_desc_t *mac_pd;
6357 crypto_key_t cipher_key;
6358 crypto_key_t mac_key;
6359 crypto_dual_data_t *dual_data =
6360 taskq_req->dr_cipher_mac_req.mr_dual_data;
6361 crypto_data_t cipher_data;
6362 crypto_data_t mac_data;
6363 crypto_mechanism_t cipher_mech, mac_mech;
6364 crypto_session_id_t session_id;
6365
6366 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
6367 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_cipher_mac_task: started\n",
6368 instance));
6369
6370 switch (taskq_req->dr_type) {
6371 case DPROV_REQ_ENCRYPT_MAC_INIT:
6372 case DPROV_REQ_MAC_DECRYPT_INIT:
6373 /* structure assignment */
6374 cipher_mech = *taskq_req->dr_cipher_mac_req.mr_cipher_mech;
6375 mac_mech = *taskq_req->dr_cipher_mac_req.mr_mac_mech;
6376
6377 /* get the keys values and providers to use for operations */
6378 if ((error = dprov_cipher_mac_key_pd(softc, ctx->cc_session,
6379 taskq_req, &cipher_key, &mac_key, &cipher_pd, &mac_pd,
6380 &cipher_mech.cm_type, &mac_mech.cm_type)) != CRYPTO_SUCCESS)
6381 break;
6382
6383 /* allocate a dprov-private context */
6384 if ((error = dprov_alloc_context(taskq_req->dr_type, ctx)) !=
6385 CRYPTO_SUCCESS)
6386 break;
6387
6388 if (taskq_req->dr_type == DPROV_REQ_ENCRYPT_MAC_INIT)
6389 /* do the encryption initialization */
6390 error = crypto_encrypt_init_prov(cipher_pd, 0,
6391 &cipher_mech, &cipher_key, NULL,
6392 &DPROV_CTX_DUAL_CIPHER(ctx), NULL);
6393 else
6394 /* do the decryption initialization */
6395 error = crypto_decrypt_init_prov(cipher_pd, 0,
6396 &cipher_mech, &cipher_key, NULL,
6397 &DPROV_CTX_DUAL_CIPHER(ctx), NULL);
6398 if (error != CRYPTO_SUCCESS)
6399 break;
6400
6401 /* do the mac initialization */
6402 if ((error = crypto_mac_init_prov(mac_pd, 0,
6403 &mac_mech, &mac_key, NULL, &DPROV_CTX_DUAL_MAC(ctx),
6404 NULL)) != CRYPTO_SUCCESS)
6405 break;
6406
6407 /* release references to providers */
6408 KCF_PROV_REFRELE(cipher_pd);
6409 KCF_PROV_REFRELE(mac_pd);
6410
6411 break;
6412
6413 case DPROV_REQ_ENCRYPT_MAC: {
6414 size_t encrypted;
6415 boolean_t inplace;
6416
6417 crypto_data_t *plaintext_tmp, *ciphertext_tmp;
6418
6419 cipher_data = *((crypto_data_t *)dual_data);
6420
6421 /* do an encrypt update */
6422 inplace = (taskq_req->dr_cipher_mac_req.mr_data == NULL);
6423 if (inplace) {
6424 plaintext_tmp = &cipher_data;
6425 ciphertext_tmp = NULL;
6426 } else {
6427 plaintext_tmp = taskq_req->dr_cipher_mac_req.mr_data;
6428 ciphertext_tmp = &cipher_data;
6429 }
6430 if ((error = crypto_encrypt_update(DPROV_CTX_DUAL_CIPHER(ctx),
6431 plaintext_tmp, ciphertext_tmp, NULL)) != CRYPTO_SUCCESS)
6432 break;
6433
6434 /* do an encrypt final */
6435 encrypted = cipher_data.cd_length;
6436
6437 cipher_data.cd_offset += encrypted;
6438 cipher_data.cd_length = dual_data->dd_len1 - encrypted;
6439
6440 if ((error = crypto_encrypt_final(DPROV_CTX_DUAL_CIPHER(ctx),
6441 &cipher_data, NULL)) != CRYPTO_SUCCESS)
6442 break;
6443
6444 /*
6445 * Do a mac update on the resulting ciphertext, but with no
6446 * more bytes than specified by dual_data, and starting at
6447 * offset specified by dual_data. For in-place operations,
6448 * we use the length specified by the dual_data.
6449 */
6450 mac_data = cipher_data;
6451 mac_data.cd_offset = dual_data->dd_offset2;
6452 mac_data.cd_length = dual_data->dd_len2;
6453 if ((error = crypto_mac_update(DPROV_CTX_DUAL_MAC(ctx),
6454 &mac_data, NULL)) != CRYPTO_SUCCESS)
6455 break;
6456
6457 /* do a mac final */
6458 error = crypto_mac_final(DPROV_CTX_DUAL_MAC(ctx),
6459 taskq_req->dr_cipher_mac_req.mr_mac, NULL);
6460
6461 /* Set the total size of the ciphertext, when successful */
6462 if (error == CRYPTO_SUCCESS)
6463 dual_data->dd_len1 = encrypted + cipher_data.cd_length;
6464
6465 if (error != CRYPTO_BUFFER_TOO_SMALL) {
6466 DPROV_CTX_DUAL_CIPHER(ctx) = NULL;
6467 DPROV_CTX_DUAL_MAC(ctx) = NULL;
6468 (void) dprov_free_context(ctx);
6469 }
6470 break;
6471 }
6472
6473 case DPROV_REQ_ENCRYPT_MAC_UPDATE: {
6474 crypto_data_t *plaintext_tmp, *ciphertext_tmp;
6475 size_t encrypted;
6476 ssize_t maclen;
6477 boolean_t inplace;
6478
6479 cipher_data = *((crypto_data_t *)dual_data);
6480
6481 /* do an encrypt update */
6482 inplace = (taskq_req->dr_cipher_mac_req.mr_data == NULL);
6483 if (inplace) {
6484 plaintext_tmp = &cipher_data;
6485 ciphertext_tmp = NULL;
6486 } else {
6487 plaintext_tmp = taskq_req->dr_cipher_mac_req.mr_data;
6488 ciphertext_tmp = &cipher_data;
6489 }
6490 if ((error = crypto_encrypt_update(DPROV_CTX_DUAL_CIPHER(ctx),
6491 plaintext_tmp, ciphertext_tmp, NULL)) != CRYPTO_SUCCESS)
6492 break;
6493
6494 encrypted = cipher_data.cd_length;
6495
6496 /*
6497 * Do a mac update on the resulting ciphertext, but with no
6498 * more bytes than specified by dual_data, and starting at
6499 * offset specified by dual_data. For in-place operations,
6500 * we use the length specified by the dual_data.
6501 * There is an edge case, when the encryption step produced
6502 * zero bytes in the ciphertext. Only the portion between
6503 * offset2 and offset1 is then thrown in the MAC mix.
6504 */
6505 maclen = dual_data->dd_offset1 - dual_data->dd_offset2 +
6506 encrypted;
6507 if (maclen > 0) {
6508 mac_data = cipher_data;
6509 mac_data.cd_offset = dual_data->dd_offset2;
6510 mac_data.cd_length = min(dual_data->dd_len2, maclen);
6511 if ((error = crypto_mac_update(DPROV_CTX_DUAL_MAC(ctx),
6512 &mac_data, NULL)) != CRYPTO_SUCCESS)
6513 break;
6514 }
6515 /* Set the total size of the ciphertext, when successful */
6516 if (error == CRYPTO_SUCCESS)
6517 dual_data->dd_len1 = encrypted;
6518
6519 break;
6520 }
6521
6522 case DPROV_REQ_ENCRYPT_MAC_FINAL:
6523 cipher_data = *((crypto_data_t *)dual_data);
6524
6525 /* do an encrypt final */
6526 if ((error = crypto_encrypt_final(DPROV_CTX_DUAL_CIPHER(ctx),
6527 taskq_req->dr_cipher_mac_req.mr_data == NULL ?
6528 &cipher_data : taskq_req->dr_cipher_mac_req.mr_data,
6529 NULL)) != CRYPTO_SUCCESS)
6530 break;
6531
6532 /*
6533 * If ciphertext length is different from zero, do a mac
6534 * update on it. This does not apply to in-place since we
6535 * do not allow partial updates, hence no final residual.
6536 */
6537 if (taskq_req->dr_cipher_mac_req.mr_data != NULL &&
6538 taskq_req->dr_cipher_mac_req.mr_data->cd_length > 0)
6539 if ((error = crypto_mac_update(DPROV_CTX_DUAL_MAC(ctx),
6540 taskq_req->dr_cipher_mac_req.mr_data, NULL)) !=
6541 CRYPTO_SUCCESS)
6542 break;
6543
6544 /* do a mac final */
6545 error = crypto_mac_final(DPROV_CTX_DUAL_MAC(ctx),
6546 taskq_req->dr_cipher_mac_req.mr_mac, NULL);
6547
6548 if (error != CRYPTO_BUFFER_TOO_SMALL) {
6549 DPROV_CTX_DUAL_CIPHER(ctx) = NULL;
6550 DPROV_CTX_DUAL_MAC(ctx) = NULL;
6551 (void) dprov_free_context(ctx);
6552 }
6553 break;
6554
6555 case DPROV_REQ_ENCRYPT_MAC_ATOMIC: {
6556 crypto_data_t *plaintext_tmp, *ciphertext_tmp;
6557 boolean_t inplace;
6558
6559 cipher_data = *((crypto_data_t *)dual_data);
6560
6561 /* do an encrypt atomic */
6562 inplace = (taskq_req->dr_cipher_mac_req.mr_data == NULL);
6563 if (inplace) {
6564 plaintext_tmp = &cipher_data;
6565 ciphertext_tmp = NULL;
6566 } else {
6567 plaintext_tmp = taskq_req->dr_cipher_mac_req.mr_data;
6568 ciphertext_tmp = &cipher_data;
6569 }
6570
6571 /* structure assignment */
6572 cipher_mech = *taskq_req->dr_cipher_mac_req.mr_cipher_mech;
6573 mac_mech = *taskq_req->dr_cipher_mac_req.mr_mac_mech;
6574 session_id = taskq_req->dr_cipher_mac_req.mr_session_id;
6575
6576 /* get the keys values and providers to use for operations */
6577 if ((error = dprov_cipher_mac_key_pd(softc, session_id,
6578 taskq_req, &cipher_key, &mac_key, &cipher_pd, &mac_pd,
6579 &cipher_mech.cm_type, &mac_mech.cm_type)) !=
6580 CRYPTO_SUCCESS)
6581 break;
6582
6583 /* do the atomic encrypt */
6584 if ((error = crypto_encrypt_prov(cipher_pd, 0,
6585 &cipher_mech, plaintext_tmp, &cipher_key, NULL,
6586 ciphertext_tmp, NULL)) != CRYPTO_SUCCESS)
6587 break;
6588
6589 /* do the atomic mac */
6590 mac_data = cipher_data;
6591 mac_data.cd_length = dual_data->dd_len2;
6592 mac_data.cd_offset = dual_data->dd_offset2;
6593 error = crypto_mac_prov(mac_pd, 0, &mac_mech, &mac_data,
6594 &mac_key, NULL, taskq_req->dr_cipher_mac_req.mr_mac, NULL);
6595
6596 dual_data->dd_len1 = cipher_data.cd_length;
6597
6598 break;
6599 }
6600
6601 case DPROV_REQ_MAC_DECRYPT: {
6602 uint_t decrypted;
6603 crypto_data_t plaintext_tmp;
6604
6605 cipher_data = *((crypto_data_t *)dual_data);
6606
6607 /* do a mac update and final on the ciphertext */
6608 if ((error = crypto_mac_update(DPROV_CTX_DUAL_MAC(ctx),
6609 &mac_data, NULL)) != CRYPTO_SUCCESS)
6610 break;
6611
6612 /* do a mac final */
6613 if ((error = crypto_mac_final(DPROV_CTX_DUAL_MAC(ctx),
6614 taskq_req->dr_cipher_mac_req.mr_mac, NULL)) !=
6615 CRYPTO_SUCCESS)
6616 break;
6617
6618 /* do an decrypt update */
6619 cipher_data = mac_data;
6620 cipher_data.cd_length = dual_data->dd_len2;
6621 cipher_data.cd_offset = dual_data->dd_offset2;
6622 if (taskq_req->dr_cipher_mac_req.mr_data == NULL)
6623 /* in-place */
6624 plaintext_tmp = cipher_data;
6625 else
6626 plaintext_tmp = *taskq_req->dr_cipher_mac_req.mr_data;
6627
6628 if ((error = crypto_decrypt_update(DPROV_CTX_DUAL_CIPHER(ctx),
6629 &cipher_data, taskq_req->dr_cipher_mac_req.mr_data,
6630 NULL)) != CRYPTO_SUCCESS)
6631 break;
6632
6633 /* do an decrypt final */
6634 if (taskq_req->dr_cipher_mac_req.mr_data == NULL)
6635 /* in-place, everything must have been decrypted */
6636 decrypted = cipher_data.cd_length;
6637 else
6638 decrypted =
6639 taskq_req->dr_cipher_mac_req.mr_data->cd_length;
6640 plaintext_tmp.cd_offset += decrypted;
6641 plaintext_tmp.cd_length -= decrypted;
6642
6643 error = crypto_decrypt_final(DPROV_CTX_DUAL_CIPHER(ctx),
6644 &plaintext_tmp, NULL);
6645 if (taskq_req->dr_cipher_mac_req.mr_data != NULL)
6646 taskq_req->dr_cipher_mac_req.mr_data->cd_length +=
6647 plaintext_tmp.cd_length;
6648
6649 if (error != CRYPTO_BUFFER_TOO_SMALL) {
6650 DPROV_CTX_DUAL_MAC(ctx) = NULL;
6651 DPROV_CTX_DUAL_CIPHER(ctx) = NULL;
6652 (void) dprov_free_context(ctx);
6653 }
6654 break;
6655 }
6656
6657 case DPROV_REQ_MAC_DECRYPT_UPDATE:
6658 cipher_data = *((crypto_data_t *)dual_data);
6659
6660 /* do mac update */
6661 if ((error = crypto_mac_update(DPROV_CTX_DUAL_MAC(ctx),
6662 &cipher_data, NULL)) != CRYPTO_SUCCESS)
6663 break;
6664
6665 /* do a decrypt update */
6666 cipher_data.cd_length = dual_data->dd_len2;
6667 cipher_data.cd_offset = dual_data->dd_offset2;
6668 error = crypto_decrypt_update(DPROV_CTX_DUAL_CIPHER(ctx),
6669 &cipher_data, taskq_req->dr_cipher_mac_req.mr_data, NULL);
6670
6671 break;
6672
6673 case DPROV_REQ_MAC_DECRYPT_FINAL:
6674 /* do a mac final */
6675 if ((error = crypto_mac_final(DPROV_CTX_DUAL_MAC(ctx),
6676 taskq_req->dr_cipher_mac_req.mr_mac, NULL)) !=
6677 CRYPTO_SUCCESS)
6678 break;
6679
6680 /* do a decrypt final */
6681 error = crypto_decrypt_final(DPROV_CTX_DUAL_CIPHER(ctx),
6682 taskq_req->dr_cipher_mac_req.mr_data, NULL);
6683
6684 if (error != CRYPTO_BUFFER_TOO_SMALL) {
6685 DPROV_CTX_DUAL_MAC(ctx) = NULL;
6686 DPROV_CTX_DUAL_CIPHER(ctx) = NULL;
6687 (void) dprov_free_context(ctx);
6688 }
6689 break;
6690
6691 case DPROV_REQ_MAC_DECRYPT_ATOMIC:
6692 case DPROV_REQ_MAC_VERIFY_DECRYPT_ATOMIC:
6693 cipher_data = *((crypto_data_t *)dual_data);
6694
6695 /* structure assignment */
6696 cipher_mech = *taskq_req->dr_cipher_mac_req.mr_cipher_mech;
6697 mac_mech = *taskq_req->dr_cipher_mac_req.mr_mac_mech;
6698 session_id = taskq_req->dr_cipher_mac_req.mr_session_id;
6699
6700 /* get the keys values and providers to use for operations */
6701 if ((error = dprov_cipher_mac_key_pd(softc, session_id,
6702 taskq_req, &cipher_key, &mac_key, &cipher_pd, &mac_pd,
6703 &cipher_mech.cm_type, &mac_mech.cm_type)) != CRYPTO_SUCCESS)
6704 break;
6705
6706 /* do the atomic mac */
6707 if (taskq_req->dr_type == DPROV_REQ_MAC_DECRYPT_ATOMIC)
6708 error = crypto_mac_prov(mac_pd, 0, &mac_mech,
6709 &cipher_data, &mac_key, NULL,
6710 taskq_req->dr_cipher_mac_req.mr_mac, NULL);
6711 else
6712 /* DPROV_REQ_MAC_VERIFY_DECRYPT_ATOMIC */
6713 error = crypto_mac_verify_prov(mac_pd, 0, &mac_mech,
6714 &cipher_data, &mac_key, NULL,
6715 taskq_req->dr_cipher_mac_req.mr_mac, NULL);
6716
6717 if (error != CRYPTO_SUCCESS)
6718 break;
6719
6720 /* do the atomic decrypt */
6721 cipher_data.cd_length = dual_data->dd_len2;
6722 cipher_data.cd_offset = dual_data->dd_offset2;
6723 error = crypto_decrypt_prov(cipher_pd, 0, &cipher_mech,
6724 &cipher_data, &cipher_key, NULL,
6725 taskq_req->dr_cipher_mac_req.mr_data, NULL);
6726
6727 break;
6728 }
6729
6730 dprov_op_done(taskq_req, error);
6731 DPROV_DEBUG(D_CIPHER_MAC, ("(%d) dprov_cipher_mac_task: end\n",
6732 instance));
6733 }
6734
6735 /*
6736 * taskq dispatcher function for random number generation.
6737 */
6738 static void
6739 dprov_random_task(dprov_req_t *taskq_req)
6740 {
6741 dprov_state_t *softc;
6742 /* LINTED E_FUNC_SET_NOT_USED */
6743 int instance;
6744 int error = CRYPTO_SUCCESS;
6745
6746 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
6747 DPROV_DEBUG(D_RANDOM, ("(%d) dprov_random_task: started\n", instance));
6748
6749 mutex_enter(&softc->ds_lock);
6750
6751 switch (taskq_req->dr_type) {
6752
6753 DPROV_REQ_RANDOM_SEED:
6754 /*
6755 * Since we don't really generate random numbers
6756 * nothing to do.
6757 */
6758 break;
6759
6760 case DPROV_REQ_RANDOM_GENERATE: {
6761 uint_t i;
6762 uchar_t c = 0;
6763
6764 /*
6765 * We don't generate random numbers so that the result
6766 * of the operation can be checked during testing.
6767 */
6768
6769 for (i = 0; i < taskq_req->dr_random_req.rr_len; i++)
6770 taskq_req->dr_random_req.rr_buf[i] = c++;
6771
6772 break;
6773 }
6774 }
6775
6776 mutex_exit(&softc->ds_lock);
6777 dprov_op_done(taskq_req, error);
6778 DPROV_DEBUG(D_RANDOM, ("(%d) dprov_random_task: end\n", instance));
6779 }
6780
6781
6782 /*
6783 * taskq dispatcher function for session management operations.
6784 */
6785 static void
6786 dprov_session_task(dprov_req_t *taskq_req)
6787 {
6788 dprov_state_t *softc;
6789 /* LINTED E_FUNC_SET_NOT_USED */
6790 int instance;
6791 int error = CRYPTO_NOT_SUPPORTED;
6792 crypto_session_id_t session_id =
6793 taskq_req->dr_session_req.sr_session_id;
6794 dprov_session_t *session;
6795 dprov_object_t *object;
6796 int i;
6797
6798 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
6799 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_task: started\n",
6800 instance));
6801
6802 mutex_enter(&softc->ds_lock);
6803
6804 if (taskq_req->dr_type != DPROV_REQ_SESSION_OPEN)
6805 /* validate session id and get ptr to session */
6806 if ((session = softc->ds_sessions[session_id]) == NULL) {
6807 mutex_exit(&softc->ds_lock);
6808 dprov_op_done(taskq_req, CRYPTO_SESSION_HANDLE_INVALID);
6809 return;
6810 }
6811
6812 switch (taskq_req->dr_type) {
6813
6814 case DPROV_REQ_SESSION_OPEN: {
6815 dprov_session_t **new_sessions;
6816
6817 if (softc->ds_token_initialized == B_FALSE) {
6818 error = CRYPTO_OPERATION_NOT_INITIALIZED;
6819 break;
6820 }
6821
6822 /* search for available session slot */
6823 for (i = 0; i < softc->ds_sessions_slots; i++)
6824 if (softc->ds_sessions[i] == NULL)
6825 break;
6826
6827 if (i == softc->ds_sessions_slots) {
6828 /* ran out of slots, grow sessions array */
6829 new_sessions = kmem_zalloc(
6830 2 * softc->ds_sessions_slots *
6831 sizeof (dprov_session_t *), KM_NOSLEEP);
6832 if (new_sessions == NULL) {
6833 error = CRYPTO_SESSION_COUNT;
6834 break;
6835 }
6836 bcopy(softc->ds_sessions, new_sessions,
6837 softc->ds_sessions_slots *
6838 sizeof (dprov_session_t *));
6839 kmem_free(softc->ds_sessions, softc->ds_sessions_slots *
6840 sizeof (dprov_session_t *));
6841 softc->ds_sessions = new_sessions;
6842 softc->ds_sessions_slots *= 2;
6843 }
6844
6845 /* allocate and initialize new session */
6846 softc->ds_sessions[i] = kmem_zalloc(
6847 sizeof (dprov_session_t), KM_NOSLEEP);
6848 if (softc->ds_sessions[i] == NULL) {
6849 error = CRYPTO_HOST_MEMORY;
6850 break;
6851 }
6852 softc->ds_sessions_count++;
6853
6854 /* initialize session state */
6855 softc->ds_sessions[i]->ds_state = DPROV_SESSION_STATE_PUBLIC;
6856
6857 /* return new session id to caller */
6858 *(taskq_req->dr_session_req.sr_session_id_ptr) = i;
6859
6860 error = CRYPTO_SUCCESS;
6861 break;
6862 }
6863
6864 case DPROV_REQ_SESSION_CLOSE:
6865 softc->ds_sessions[session_id] = NULL;
6866
6867 if (softc->ds_token_initialized == B_FALSE) {
6868 error = CRYPTO_OPERATION_NOT_INITIALIZED;
6869 break;
6870 }
6871
6872 dprov_release_session_objects(session);
6873
6874 /* free session state and corresponding slot */
6875 kmem_free(session, sizeof (dprov_session_t));
6876 softc->ds_sessions_count--;
6877
6878 error = CRYPTO_SUCCESS;
6879 break;
6880
6881 case DPROV_REQ_SESSION_LOGIN: {
6882 char *pin = taskq_req->dr_session_req.sr_pin;
6883 size_t pin_len = taskq_req->dr_session_req.sr_pin_len;
6884 crypto_user_type_t user_type =
6885 taskq_req->dr_session_req.sr_user_type;
6886
6887 /* check user type */
6888 if (user_type != CRYPTO_SO && user_type != CRYPTO_USER) {
6889 error = CRYPTO_USER_TYPE_INVALID;
6890 break;
6891 }
6892
6893 /* check pin length */
6894 if (pin_len > DPROV_MAX_PIN_LEN) {
6895 error = CRYPTO_PIN_LEN_RANGE;
6896 break;
6897 }
6898
6899 /* check pin */
6900 if (pin == NULL) {
6901 error = CRYPTO_PIN_INVALID;
6902 break;
6903 }
6904
6905 /* validate PIN state */
6906 if ((user_type == CRYPTO_SO) && !softc->ds_token_initialized ||
6907 (user_type == CRYPTO_USER) && !softc->ds_user_pin_set) {
6908 error = CRYPTO_USER_PIN_NOT_INITIALIZED;
6909 break;
6910 }
6911
6912 if ((user_type == CRYPTO_SO &&
6913 softc->ds_sessions[session_id]->ds_state ==
6914 DPROV_SESSION_STATE_SO) ||
6915 (user_type == CRYPTO_USER &&
6916 softc->ds_sessions[session_id]->ds_state ==
6917 DPROV_SESSION_STATE_USER)) {
6918 /* SO or user already logged in */
6919 error = CRYPTO_USER_ALREADY_LOGGED_IN;
6920 break;
6921 }
6922
6923 if (softc->ds_sessions[session_id]->ds_state !=
6924 DPROV_SESSION_STATE_PUBLIC) {
6925 /* another user already logged in */
6926 error = CRYPTO_USER_ANOTHER_ALREADY_LOGGED_IN;
6927 break;
6928 }
6929
6930 /* everything's fine, update session */
6931 softc->ds_sessions[session_id]->ds_state =
6932 user_type == CRYPTO_SO ?
6933 DPROV_SESSION_STATE_SO : DPROV_SESSION_STATE_USER;
6934
6935 error = CRYPTO_SUCCESS;
6936 break;
6937 }
6938
6939 case DPROV_REQ_SESSION_LOGOUT:
6940 /* fail if not logged in */
6941 if (softc->ds_sessions[session_id]->ds_state ==
6942 DPROV_SESSION_STATE_PUBLIC) {
6943 error = CRYPTO_USER_NOT_LOGGED_IN;
6944 break;
6945 }
6946
6947 /*
6948 * Destroy all private session objects.
6949 * Invalidate handles to all private objects.
6950 */
6951 for (i = 0; i < DPROV_MAX_OBJECTS; i++) {
6952 object = softc->ds_sessions[session_id]->ds_objects[i];
6953 if (object != NULL && dprov_object_is_private(object)) {
6954 if (!dprov_object_is_token(object))
6955 /* It's a session object, free it */
6956 DPROV_OBJECT_REFRELE(object);
6957 softc->ds_sessions[session_id]->ds_objects[i] =
6958 NULL;
6959 }
6960 }
6961
6962 /* update session state */
6963 softc->ds_sessions[session_id]->ds_state =
6964 DPROV_SESSION_STATE_PUBLIC;
6965
6966 error = CRYPTO_SUCCESS;
6967 break;
6968 }
6969
6970 mutex_exit(&softc->ds_lock);
6971 dprov_op_done(taskq_req, error);
6972 DPROV_DEBUG(D_SESSION, ("(%d) dprov_session_task: end\n", instance));
6973 }
6974
6975 /* return true if attribute is defined to be a PKCS#11 long */
6976 static boolean_t
6977 fixed_size_attribute(crypto_attr_type_t type)
6978 {
6979 return (type == DPROV_CKA_CLASS ||
6980 type == DPROV_CKA_CERTIFICATE_TYPE ||
6981 type == DPROV_CKA_KEY_TYPE ||
6982 type == DPROV_HW_FEATURE_TYPE);
6983 }
6984
6985 /*
6986 * Attributes defined to be a PKCS#11 long causes problems for dprov
6987 * because 32-bit applications set the size to 4 and 64-bit applications
6988 * set the size to 8. dprov always stores these fixed-size attributes
6989 * as uint32_t.
6990 */
6991 static ssize_t
6992 attribute_size(crypto_attr_type_t type, ssize_t len)
6993 {
6994 if (fixed_size_attribute(type))
6995 return (sizeof (uint32_t));
6996
6997 return (len);
6998 }
6999
7000 /*
7001 * taskq dispatcher function for object management operations.
7002 */
7003 static void
7004 dprov_object_task(dprov_req_t *taskq_req)
7005 {
7006 dprov_state_t *softc;
7007 /* LINTED E_FUNC_SET_NOT_USED */
7008 int instance;
7009 int error = CRYPTO_NOT_SUPPORTED;
7010 crypto_object_id_t object_id = taskq_req->dr_object_req.or_object_id;
7011 crypto_session_id_t session_id = taskq_req->dr_object_req.or_session_id;
7012 crypto_object_attribute_t *template =
7013 taskq_req->dr_object_req.or_template;
7014 uint_t attr_count = taskq_req->dr_object_req.or_attribute_count;
7015 dprov_object_t *object;
7016 dprov_session_t *session;
7017
7018 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
7019 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_task: started\n", instance));
7020
7021 mutex_enter(&softc->ds_lock);
7022
7023 /* validate session id and get ptr to session */
7024 if ((session = softc->ds_sessions[session_id]) == NULL) {
7025 mutex_exit(&softc->ds_lock);
7026 dprov_op_done(taskq_req, CRYPTO_SESSION_HANDLE_INVALID);
7027 return;
7028 }
7029
7030 switch (taskq_req->dr_type) {
7031
7032 case DPROV_REQ_OBJECT_CREATE:
7033 /* create the object from the specified template */
7034 if ((error = dprov_create_object_from_template(softc, session,
7035 template, attr_count,
7036 taskq_req->dr_object_req.or_object_id_ptr, B_TRUE,
7037 B_FALSE)) != CRYPTO_SUCCESS)
7038 break;
7039
7040 break;
7041
7042 case DPROV_REQ_OBJECT_COPY:
7043 /* check object id */
7044 if (object_id >= DPROV_MAX_OBJECTS ||
7045 (object = session->ds_objects[object_id]) == NULL) {
7046 error = CRYPTO_OBJECT_HANDLE_INVALID;
7047 break;
7048 }
7049
7050 /*
7051 * Create a new object from the object passed as
7052 * argument.
7053 */
7054 if ((error = dprov_create_object_from_template(softc, session,
7055 object->do_attr, DPROV_MAX_ATTR,
7056 taskq_req->dr_object_req.or_object_id_ptr, B_TRUE,
7057 B_FALSE)) != CRYPTO_SUCCESS)
7058 break;
7059
7060 /*
7061 * Add the attributes specified by the template to the
7062 * newly created object, replacing existing ones if needed.
7063 */
7064 error = dprov_object_set_attr(session,
7065 *taskq_req->dr_object_req.or_object_id_ptr,
7066 taskq_req->dr_object_req.or_template,
7067 taskq_req->dr_object_req.or_attribute_count, B_TRUE);
7068
7069 break;
7070
7071 case DPROV_REQ_OBJECT_DESTROY:
7072 /* destroy the object */
7073 error = dprov_destroy_object(softc, session,
7074 taskq_req->dr_object_req.or_object_id);
7075
7076 break;
7077
7078 case DPROV_REQ_OBJECT_GET_SIZE:
7079 /* get ptr to object */
7080 if (object_id >= DPROV_MAX_OBJECTS ||
7081 session->ds_objects[object_id] == NULL) {
7082 error = CRYPTO_OBJECT_HANDLE_INVALID;
7083 break;
7084 }
7085
7086 /*
7087 * The PKCS11 specification does not specifies what
7088 * the object size really is, here we just return
7089 * the number of possible attributes of the object.
7090 */
7091 *taskq_req->dr_object_req.or_object_size = DPROV_MAX_ATTR;
7092
7093 error = CRYPTO_SUCCESS;
7094 break;
7095
7096 case DPROV_REQ_OBJECT_GET_ATTRIBUTE_VALUE: {
7097 crypto_attr_type_t type;
7098 size_t olen, tlen;
7099 offset_t offset;
7100 int tmpl_idx;
7101 int object_idx;
7102 ulong_t class = DPROV_CKO_DATA;
7103 boolean_t extractable = B_TRUE;
7104
7105 error = CRYPTO_SUCCESS;
7106
7107 /* get ptr to object */
7108 if (object_id >= DPROV_MAX_OBJECTS ||
7109 (object = session->ds_objects[object_id]) == NULL) {
7110 error = CRYPTO_OBJECT_HANDLE_INVALID;
7111 break;
7112 }
7113
7114 (void) dprov_get_object_attr_boolean(object,
7115 DPROV_CKA_EXTRACTABLE, &extractable);
7116
7117 (void) dprov_get_object_attr_ulong(object,
7118 DPROV_CKA_CLASS, &class);
7119
7120 /* return the specified attributes, when possible */
7121 for (tmpl_idx = 0; tmpl_idx < attr_count; tmpl_idx++) {
7122 /*
7123 * Attribute can't be revealed if the CKA_EXTRACTABLE
7124 * attribute is set to false.
7125 */
7126 type = template[tmpl_idx].oa_type;
7127 if (!extractable && class == DPROV_CKO_SECRET_KEY) {
7128 if (type == DPROV_CKA_VALUE) {
7129 template[tmpl_idx].oa_value_len = -1;
7130 error = CRYPTO_ATTRIBUTE_SENSITIVE;
7131 continue;
7132 }
7133 }
7134 if (!extractable && class == DPROV_CKO_PRIVATE_KEY) {
7135 if (type == DPROV_CKA_PRIVATE_EXPONENT) {
7136 template[tmpl_idx].oa_value_len = -1;
7137 error = CRYPTO_ATTRIBUTE_SENSITIVE;
7138 continue;
7139 }
7140 }
7141
7142 object_idx = dprov_find_attr(object->do_attr,
7143 DPROV_MAX_ATTR, type);
7144 if (object_idx == -1) {
7145 /* attribute not found in object */
7146 template[tmpl_idx].oa_value_len = -1;
7147 error = CRYPTO_ATTRIBUTE_TYPE_INVALID;
7148 continue;
7149 }
7150
7151 tlen = template[tmpl_idx].oa_value_len;
7152 olen = object->do_attr[object_idx].oa_value_len;
7153 /* return attribute length */
7154 if (template[tmpl_idx].oa_value == NULL) {
7155 /*
7156 * The size of the attribute is set by the
7157 * library according to the data model of the
7158 * application, so don't overwrite it with
7159 * dprov's size.
7160 */
7161 if (!fixed_size_attribute(type))
7162 template[tmpl_idx].oa_value_len = olen;
7163 continue;
7164 }
7165
7166 if (tlen < olen) {
7167 template[tmpl_idx].oa_value_len = -1;
7168 error = CRYPTO_BUFFER_TOO_SMALL;
7169 continue;
7170 }
7171
7172 /* copy attribute value */
7173 bzero(template[tmpl_idx].oa_value, tlen);
7174
7175 offset = 0;
7176 #ifdef _BIG_ENDIAN
7177 if (fixed_size_attribute(type)) {
7178 offset = tlen - olen;
7179 }
7180 #endif
7181 bcopy(object->do_attr[object_idx].oa_value,
7182 &template[tmpl_idx].oa_value[offset], olen);
7183
7184 /* don't update length for fixed-size attributes */
7185 if (!fixed_size_attribute(type))
7186 template[tmpl_idx].oa_value_len = olen;
7187 }
7188
7189 break;
7190 }
7191
7192 case DPROV_REQ_OBJECT_SET_ATTRIBUTE_VALUE:
7193 /*
7194 * Add the attributes specified by the template to the
7195 * newly created object, replacing existing ones if needed.
7196 */
7197 error = dprov_object_set_attr(session,
7198 taskq_req->dr_object_req.or_object_id,
7199 taskq_req->dr_object_req.or_template,
7200 taskq_req->dr_object_req.or_attribute_count, B_TRUE);
7201
7202 break;
7203
7204 case DPROV_REQ_OBJECT_FIND_INIT: {
7205 dprov_find_ctx_t *find_ctx;
7206 int so_idx; /* session object index */
7207 int to_idx; /* token object index */
7208
7209 error = CRYPTO_SUCCESS;
7210 /* allocate find context */
7211 find_ctx = kmem_zalloc(sizeof (dprov_find_ctx_t), KM_SLEEP);
7212 *taskq_req->dr_object_req.or_find_pp = find_ctx;
7213
7214 /* first go through the existing session objects */
7215 for (so_idx = 0; so_idx < DPROV_MAX_OBJECTS; so_idx++) {
7216 if ((object = session->ds_objects[so_idx]) == NULL)
7217 continue;
7218
7219 /* setting count to zero means find all objects */
7220 if (attr_count > 0) {
7221 if (!dprov_attributes_match(object, template,
7222 attr_count))
7223 continue;
7224 }
7225
7226 /* session object attributes matches template */
7227 find_ctx->fc_ids[find_ctx->fc_nids] = so_idx;
7228 find_ctx->fc_nids++;
7229 }
7230
7231 /*
7232 * Go through the token object. For each token object
7233 * that can be accessed:
7234 * If there was already an session object id assigned
7235 * to that token object, skip it, since it was returned
7236 * during the check of session objects, else,
7237 * assign a new object id for that token object and
7238 * add it to the array of matching objects.
7239 */
7240 for (to_idx = 0; to_idx < DPROV_MAX_OBJECTS &&
7241 error == CRYPTO_SUCCESS; to_idx++) {
7242 if ((object = softc->ds_objects[to_idx]) == NULL)
7243 continue;
7244
7245 /* setting count to zero means find all objects */
7246 if (attr_count > 0) {
7247 if (!dprov_attributes_match(object, template,
7248 attr_count))
7249 continue;
7250 }
7251
7252 /* if the the object has been destroyed, skip it */
7253 if (object->do_destroyed)
7254 continue;
7255
7256 /* skip object if it cannot be accessed from session */
7257 if (dprov_object_is_private(object) &&
7258 session->ds_state != DPROV_SESSION_STATE_USER)
7259 continue;
7260
7261 /*
7262 * Is there already a session object id for this
7263 * token object?
7264 */
7265 for (so_idx = 0; so_idx < DPROV_MAX_OBJECTS; so_idx++)
7266 if (session->ds_objects[so_idx] != NULL &&
7267 session->ds_objects[so_idx]->do_token_idx ==
7268 to_idx)
7269 break;
7270 if (so_idx < DPROV_MAX_OBJECTS)
7271 /* object found in session table, skip it */
7272 continue;
7273
7274 /* find free session slot for this object */
7275 for (so_idx = 0; so_idx < DPROV_MAX_OBJECTS; so_idx++)
7276 if (session->ds_objects[so_idx] == NULL)
7277 break;
7278 if (so_idx == DPROV_MAX_OBJECTS) {
7279 /* ran out of session objects slots */
7280 kmem_free(find_ctx, sizeof (dprov_find_ctx_t));
7281 error = CRYPTO_HOST_MEMORY;
7282 break;
7283 }
7284
7285 /* add object to session objects table */
7286 session->ds_objects[so_idx] = object;
7287 DPROV_OBJECT_REFHOLD(object);
7288
7289 /* add object to list of objects to return */
7290 find_ctx->fc_ids[find_ctx->fc_nids] = so_idx;
7291 find_ctx->fc_nids++;
7292 }
7293
7294 break;
7295 }
7296
7297 case DPROV_REQ_OBJECT_FIND: {
7298 crypto_object_id_t *object_ids =
7299 taskq_req->dr_object_req.or_object_id_ptr;
7300 uint_t max_object_count =
7301 taskq_req->dr_object_req.or_max_object_count;
7302 dprov_find_ctx_t *find_ctx =
7303 taskq_req->dr_object_req.or_find_p;
7304 uint_t ret_oid_idx;
7305
7306 /* return the desired number of object ids */
7307 for (ret_oid_idx = 0; ret_oid_idx < max_object_count &&
7308 find_ctx->fc_next < find_ctx->fc_nids; ret_oid_idx++)
7309 object_ids[ret_oid_idx] =
7310 find_ctx->fc_ids[find_ctx->fc_next++];
7311
7312 *taskq_req->dr_object_req.or_object_count_ptr = ret_oid_idx;
7313
7314 error = CRYPTO_SUCCESS;
7315 break;
7316 }
7317
7318 case DPROV_REQ_OBJECT_FIND_FINAL:
7319 kmem_free(taskq_req->dr_object_req.or_find_p,
7320 sizeof (dprov_find_ctx_t));
7321
7322 error = CRYPTO_SUCCESS;
7323 break;
7324 }
7325
7326 mutex_exit(&softc->ds_lock);
7327 dprov_op_done(taskq_req, error);
7328 DPROV_DEBUG(D_OBJECT, ("(%d) dprov_object_task: end\n", instance));
7329 }
7330
7331 /*
7332 * Copy attribute values into a template. RSA values are precomputed.
7333 */
7334 static int
7335 nostore_copy_attribute(crypto_object_attribute_t *template, uint_t count,
7336 uint64_t attr_type)
7337 {
7338 void *value, *dprov_attribute_value;
7339 size_t dprov_attribute_size;
7340 size_t value_len = 0;
7341 int error;
7342
7343 switch (attr_type) {
7344 case DPROV_CKA_VALUE:
7345 dprov_attribute_size = sizeof (dh_value);
7346 dprov_attribute_value = dh_value;
7347 break;
7348
7349 case DPROV_CKA_MODULUS:
7350 dprov_attribute_size = sizeof (modulus);
7351 dprov_attribute_value = modulus;
7352 break;
7353
7354 case DPROV_CKA_PUBLIC_EXPONENT:
7355 dprov_attribute_size = sizeof (public_exponent);
7356 dprov_attribute_value = public_exponent;
7357 break;
7358
7359 case DPROV_CKA_PRIVATE_EXPONENT:
7360 dprov_attribute_size = sizeof (private_exponent);
7361 dprov_attribute_value = private_exponent;
7362 break;
7363
7364 default:
7365 return (CRYPTO_ATTRIBUTE_TYPE_INVALID);
7366 }
7367
7368 error = dprov_get_template_attr_array(template, count, attr_type,
7369 &value, &value_len);
7370 if (error != CRYPTO_SUCCESS)
7371 return (error);
7372
7373 if (value_len < dprov_attribute_size)
7374 return (CRYPTO_BUFFER_TOO_SMALL);
7375
7376 /*
7377 * The updated template will be returned to libpkcs11.
7378 */
7379 bcopy(dprov_attribute_value, value, dprov_attribute_size);
7380
7381 return (CRYPTO_SUCCESS);
7382 }
7383
7384 static void
7385 fill_dh(void *value, size_t len)
7386 {
7387 int i = 0;
7388 char *p = value;
7389 while (i < len) {
7390 p[i++] = 'D';
7391 if (i >= len)
7392 break;
7393 p[i++] = 'H';
7394 }
7395 }
7396
7397 /*
7398 * taskq dispatcher function for key management operations.
7399 */
7400 static void
7401 dprov_key_task(dprov_req_t *taskq_req)
7402 {
7403 dprov_state_t *softc;
7404 /* LINTED E_FUNC_SET_NOT_USED */
7405 int instance;
7406 int error = CRYPTO_NOT_SUPPORTED;
7407 kcf_provider_desc_t *pd;
7408 crypto_session_id_t session_id = taskq_req->dr_key_req.kr_session_id;
7409 dprov_session_t *session;
7410
7411 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
7412 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_task: started\n", instance));
7413
7414 mutex_enter(&softc->ds_lock);
7415
7416 /* validate session id and get ptr to session */
7417 if ((session = softc->ds_sessions[session_id]) == NULL) {
7418 mutex_exit(&softc->ds_lock);
7419 dprov_op_done(taskq_req, CRYPTO_SESSION_HANDLE_INVALID);
7420 return;
7421 }
7422
7423 switch (taskq_req->dr_type) {
7424 case DPROV_REQ_KEY_GENERATE: {
7425 crypto_mechanism_t *mechp;
7426 crypto_object_id_t *object_id_ptr;
7427 crypto_object_attribute_t *template;
7428 crypto_object_attribute_t attribute;
7429 uint_t attribute_count;
7430 ulong_t key_type = ~0UL, class = ~0UL;
7431 ulong_t value_len;
7432 size_t key_len = 0;
7433
7434 error = CRYPTO_SUCCESS;
7435
7436 template = taskq_req->dr_key_req.kr_template;
7437 attribute_count = taskq_req->dr_key_req.kr_attribute_count;
7438 object_id_ptr = taskq_req->dr_key_req.kr_object_id_ptr;
7439 mechp = taskq_req->dr_key_req.kr_mechanism;
7440
7441 /* optional */
7442 (void) dprov_get_template_attr_ulong(template, attribute_count,
7443 DPROV_CKA_CLASS, &class);
7444
7445 /* optional */
7446 (void) dprov_get_template_attr_ulong(template, attribute_count,
7447 DPROV_CKA_KEY_TYPE, &key_type);
7448
7449 if (class != ~0UL && class != DPROV_CKO_SECRET_KEY) {
7450 error = CRYPTO_TEMPLATE_INCONSISTENT;
7451 break;
7452 }
7453
7454 switch (mechp->cm_type) {
7455 case DES_KEY_GEN_MECH_INFO_TYPE:
7456 if (key_type != ~0UL && key_type != DPROV_CKK_DES) {
7457 error = CRYPTO_TEMPLATE_INCONSISTENT;
7458 break;
7459 }
7460 key_len = DES_KEY_LEN;
7461 key_type = DPROV_CKK_DES;
7462 break;
7463
7464 case DES3_KEY_GEN_MECH_INFO_TYPE:
7465 if (key_type != ~0UL && key_type != DPROV_CKK_DES3) {
7466 error = CRYPTO_TEMPLATE_INCONSISTENT;
7467 break;
7468 }
7469 key_len = DES3_KEY_LEN;
7470 key_type = DPROV_CKK_DES3;
7471 break;
7472
7473 case AES_KEY_GEN_MECH_INFO_TYPE:
7474 if (key_type != ~0UL && key_type != DPROV_CKK_AES) {
7475 error = CRYPTO_TEMPLATE_INCONSISTENT;
7476 break;
7477 }
7478 if (dprov_get_template_attr_ulong(template,
7479 attribute_count, DPROV_CKA_VALUE_LEN,
7480 &value_len) != CRYPTO_SUCCESS) {
7481 error = CRYPTO_TEMPLATE_INCOMPLETE;
7482 break;
7483 }
7484 if (value_len >= AES_MAX_KEY_LEN) {
7485 error = CRYPTO_ATTRIBUTE_VALUE_INVALID;
7486 break;
7487 }
7488 key_len = value_len;
7489 key_type = DPROV_CKK_AES;
7490 break;
7491
7492 case BLOWFISH_KEY_GEN_MECH_INFO_TYPE:
7493 if (key_type != ~0UL &&
7494 key_type != DPROV_CKK_BLOWFISH) {
7495 error = CRYPTO_TEMPLATE_INCONSISTENT;
7496 break;
7497 }
7498 if (dprov_get_template_attr_ulong(template,
7499 attribute_count, DPROV_CKA_VALUE_LEN,
7500 &value_len) != CRYPTO_SUCCESS) {
7501 error = CRYPTO_TEMPLATE_INCOMPLETE;
7502 break;
7503 }
7504 if (value_len >= BLOWFISH_MAX_KEY_LEN) {
7505 error = CRYPTO_ATTRIBUTE_VALUE_INVALID;
7506 break;
7507 }
7508 key_len = value_len;
7509 key_type = DPROV_CKK_BLOWFISH;
7510 break;
7511
7512 case RC4_KEY_GEN_MECH_INFO_TYPE:
7513 if (key_type != ~0UL && key_type != DPROV_CKK_RC4) {
7514 error = CRYPTO_TEMPLATE_INCONSISTENT;
7515 break;
7516 }
7517 if (dprov_get_template_attr_ulong(template,
7518 attribute_count, DPROV_CKA_VALUE_LEN,
7519 &value_len) != CRYPTO_SUCCESS) {
7520 error = CRYPTO_TEMPLATE_INCOMPLETE;
7521 break;
7522 }
7523 if (value_len >=
7524 CRYPTO_BITS2BYTES(ARCFOUR_MAX_KEY_BITS)) {
7525 error = CRYPTO_ATTRIBUTE_VALUE_INVALID;
7526 break;
7527 }
7528 key_len = value_len;
7529 key_type = DPROV_CKK_RC4;
7530 break;
7531
7532 default:
7533 error = CRYPTO_MECHANISM_INVALID;
7534 }
7535
7536 if (error != CRYPTO_SUCCESS)
7537 break;
7538
7539 error = dprov_create_object_from_template(softc, session,
7540 template, attribute_count, object_id_ptr, B_FALSE, B_TRUE);
7541
7542 if (error != CRYPTO_SUCCESS)
7543 break;
7544
7545 /* make sure class is set */
7546 attribute.oa_type = DPROV_CKA_CLASS;
7547 attribute.oa_value = (char *)&class;
7548 attribute.oa_value_len = sizeof (ulong_t);
7549 error = dprov_object_set_attr(session, *object_id_ptr,
7550 &attribute, 1, B_FALSE);
7551
7552 if (error != CRYPTO_SUCCESS) {
7553 goto destroy_object;
7554 }
7555
7556 /* make sure key_type is set */
7557 attribute.oa_type = DPROV_CKA_KEY_TYPE;
7558 attribute.oa_value = (char *)&key_type;
7559 attribute.oa_value_len = sizeof (ulong_t);
7560 error = dprov_object_set_attr(session, *object_id_ptr,
7561 &attribute, 1, B_FALSE);
7562
7563 if (error != CRYPTO_SUCCESS) {
7564 goto destroy_object;
7565 }
7566
7567 attribute.oa_type = DPROV_CKA_VALUE;
7568 attribute.oa_value = kmem_alloc(key_len, KM_SLEEP);
7569 attribute.oa_value_len = key_len;
7570
7571 if (random_get_pseudo_bytes((uchar_t *)attribute.oa_value,
7572 key_len) != 0) {
7573 bzero(attribute.oa_value, key_len);
7574 kmem_free(attribute.oa_value, key_len);
7575 goto destroy_object;
7576 }
7577 error = dprov_object_set_attr(session, *object_id_ptr,
7578 &attribute, 1, B_FALSE);
7579
7580 bzero(attribute.oa_value, key_len);
7581 kmem_free(attribute.oa_value, key_len);
7582
7583 if (error != CRYPTO_SUCCESS) {
7584 goto destroy_object;
7585 }
7586 break;
7587
7588 destroy_object:
7589 (void) dprov_destroy_object(softc, session, *object_id_ptr);
7590 break;
7591 }
7592
7593 case DPROV_REQ_KEY_GENERATE_PAIR: {
7594 crypto_mechanism_t *mechp;
7595 crypto_object_id_t *pub_object_id_ptr;
7596 crypto_object_id_t *pri_object_id_ptr;
7597 crypto_object_attribute_t *pub_template;
7598 crypto_object_attribute_t *pri_template;
7599 crypto_object_attribute_t attribute;
7600 uint_t pub_attribute_count;
7601 uint_t pri_attribute_count;
7602 ulong_t pub_key_type = ~0UL, pub_class = ~0UL;
7603 ulong_t pri_key_type = ~0UL, pri_class = ~0UL;
7604
7605 pub_template = taskq_req->dr_key_req.kr_template;
7606 pub_attribute_count = taskq_req->dr_key_req.kr_attribute_count;
7607 pub_object_id_ptr = taskq_req->dr_key_req.kr_object_id_ptr;
7608 pri_template = taskq_req->dr_key_req.kr_private_key_template;
7609 pri_attribute_count =
7610 taskq_req->dr_key_req.kr_private_key_attribute_count;
7611 pri_object_id_ptr =
7612 taskq_req->dr_key_req.kr_private_key_object_id_ptr;
7613 mechp = taskq_req->dr_key_req.kr_mechanism;
7614
7615 error = CRYPTO_SUCCESS;
7616
7617 /* optional */
7618 (void) dprov_get_template_attr_ulong(pub_template,
7619 pub_attribute_count, DPROV_CKA_CLASS, &pub_class);
7620
7621 /* optional */
7622 (void) dprov_get_template_attr_ulong(pri_template,
7623 pri_attribute_count, DPROV_CKA_CLASS, &pri_class);
7624
7625 /* optional */
7626 (void) dprov_get_template_attr_ulong(pub_template,
7627 pub_attribute_count, DPROV_CKA_KEY_TYPE, &pub_key_type);
7628
7629 /* optional */
7630 (void) dprov_get_template_attr_ulong(pri_template,
7631 pri_attribute_count, DPROV_CKA_KEY_TYPE, &pri_key_type);
7632
7633 if (pub_class != ~0UL && pub_class != DPROV_CKO_PUBLIC_KEY) {
7634 error = CRYPTO_TEMPLATE_INCONSISTENT;
7635 break;
7636 }
7637
7638 if (pri_class != ~0UL && pri_class != DPROV_CKO_PRIVATE_KEY) {
7639 error = CRYPTO_TEMPLATE_INCONSISTENT;
7640 break;
7641 }
7642
7643 switch (mechp->cm_type) {
7644 case RSA_PKCS_KEY_PAIR_GEN_MECH_INFO_TYPE:
7645 if (pub_key_type != ~0UL &&
7646 pub_key_type != DPROV_CKK_RSA) {
7647 error = CRYPTO_TEMPLATE_INCONSISTENT;
7648 break;
7649 }
7650 pub_key_type = DPROV_CKK_RSA;
7651
7652 if (pri_key_type != ~0UL &&
7653 pri_key_type != DPROV_CKK_RSA) {
7654 error = CRYPTO_TEMPLATE_INCONSISTENT;
7655 break;
7656 }
7657 pri_key_type = DPROV_CKK_RSA;
7658
7659 if (pub_class != ~0UL &&
7660 pub_class != DPROV_CKO_PUBLIC_KEY) {
7661 error = CRYPTO_TEMPLATE_INCONSISTENT;
7662 break;
7663 }
7664 pub_class = DPROV_CKO_PUBLIC_KEY;
7665
7666 if (pri_class != ~0UL &&
7667 pri_class != DPROV_CKO_PRIVATE_KEY) {
7668 error = CRYPTO_TEMPLATE_INCONSISTENT;
7669 break;
7670 }
7671 pri_class = DPROV_CKO_PRIVATE_KEY;
7672 break;
7673
7674 default:
7675 error = CRYPTO_MECHANISM_INVALID;
7676 }
7677
7678 if (error != CRYPTO_SUCCESS)
7679 break;
7680
7681 error = dprov_create_object_from_template(softc, session,
7682 pub_template, pub_attribute_count, pub_object_id_ptr,
7683 B_FALSE, B_TRUE);
7684
7685 if (error != CRYPTO_SUCCESS)
7686 break;
7687
7688 /* make sure class is set */
7689 attribute.oa_type = DPROV_CKA_CLASS;
7690 attribute.oa_value = (char *)&pub_class;
7691 attribute.oa_value_len = sizeof (ulong_t);
7692 error = dprov_object_set_attr(session, *pub_object_id_ptr,
7693 &attribute, 1, B_FALSE);
7694
7695 if (error != CRYPTO_SUCCESS) {
7696 goto destroy_public_object;
7697 }
7698
7699 /* make sure key_type is set */
7700 attribute.oa_type = DPROV_CKA_KEY_TYPE;
7701 attribute.oa_value = (char *)&pub_key_type;
7702 attribute.oa_value_len = sizeof (ulong_t);
7703 error = dprov_object_set_attr(session, *pub_object_id_ptr,
7704 &attribute, 1, B_FALSE);
7705
7706 if (error != CRYPTO_SUCCESS) {
7707 goto destroy_public_object;
7708 }
7709
7710 attribute.oa_type = DPROV_CKA_MODULUS;
7711 attribute.oa_value = (char *)modulus;
7712 attribute.oa_value_len = sizeof (modulus);
7713 error = dprov_object_set_attr(session, *pub_object_id_ptr,
7714 &attribute, 1, B_FALSE);
7715
7716 if (error != CRYPTO_SUCCESS) {
7717 goto destroy_public_object;
7718 }
7719
7720 attribute.oa_type = DPROV_CKA_PUBLIC_EXPONENT;
7721 attribute.oa_value = public_exponent;
7722 attribute.oa_value_len = sizeof (public_exponent);
7723 error = dprov_object_set_attr(session, *pub_object_id_ptr,
7724 &attribute, 1, B_FALSE);
7725
7726 if (error != CRYPTO_SUCCESS) {
7727 goto destroy_public_object;
7728 }
7729
7730 error = dprov_create_object_from_template(softc, session,
7731 pri_template, pri_attribute_count, pri_object_id_ptr,
7732 B_FALSE, B_TRUE);
7733
7734 if (error != CRYPTO_SUCCESS)
7735 break;
7736
7737 /* make sure class is set */
7738 attribute.oa_type = DPROV_CKA_CLASS;
7739 attribute.oa_value = (char *)&pri_class;
7740 attribute.oa_value_len = sizeof (ulong_t);
7741 error = dprov_object_set_attr(session, *pri_object_id_ptr,
7742 &attribute, 1, B_FALSE);
7743
7744 if (error != CRYPTO_SUCCESS) {
7745 goto destroy_private_object;
7746 }
7747
7748 /* make sure key_type is set */
7749 attribute.oa_type = DPROV_CKA_KEY_TYPE;
7750 attribute.oa_value = (char *)&pri_key_type;
7751 attribute.oa_value_len = sizeof (ulong_t);
7752 error = dprov_object_set_attr(session, *pri_object_id_ptr,
7753 &attribute, 1, B_FALSE);
7754
7755 if (error != CRYPTO_SUCCESS) {
7756 goto destroy_private_object;
7757 }
7758
7759 attribute.oa_type = DPROV_CKA_MODULUS;
7760 attribute.oa_value = (char *)modulus;
7761 attribute.oa_value_len = sizeof (modulus);
7762 error = dprov_object_set_attr(session, *pri_object_id_ptr,
7763 &attribute, 1, B_FALSE);
7764
7765 if (error != CRYPTO_SUCCESS) {
7766 goto destroy_private_object;
7767 }
7768
7769 attribute.oa_type = DPROV_CKA_PRIVATE_EXPONENT;
7770 attribute.oa_value = (char *)private_exponent;
7771 attribute.oa_value_len = sizeof (private_exponent);
7772 error = dprov_object_set_attr(session, *pri_object_id_ptr,
7773 &attribute, 1, B_FALSE);
7774
7775 if (error != CRYPTO_SUCCESS) {
7776 goto destroy_private_object;
7777 }
7778 break;
7779
7780 destroy_private_object:
7781 (void) dprov_destroy_object(softc, session,
7782 *pri_object_id_ptr);
7783 destroy_public_object:
7784 (void) dprov_destroy_object(softc, session,
7785 *pub_object_id_ptr);
7786
7787 break;
7788 }
7789
7790 case DPROV_REQ_KEY_WRAP: {
7791 crypto_mechanism_t mech, *mechp;
7792 crypto_key_t key, *keyp;
7793 crypto_object_id_t object_id;
7794 ulong_t class = DPROV_CKO_DATA;
7795 boolean_t extractable = B_TRUE;
7796 dprov_object_t *object;
7797 int object_idx;
7798 char *plaintext_key;
7799 size_t plaintext_key_len;
7800 crypto_data_t plaintext;
7801 crypto_data_t ciphertext;
7802 size_t *lenp;
7803
7804 mechp = taskq_req->dr_key_req.kr_mechanism;
7805 /* structure assignment */
7806 mech = *mechp;
7807
7808 /* get wrapping key value */
7809 if (is_publickey_mech(mech.cm_type)) {
7810 if ((error = dprov_key_attr_asymmetric(softc,
7811 session_id, taskq_req->dr_type,
7812 taskq_req->dr_key_req.kr_key,
7813 &key)) != CRYPTO_SUCCESS)
7814 break;
7815 keyp = &key;
7816 } else {
7817 if ((error = dprov_key_value_secret(softc,
7818 session_id, taskq_req->dr_type,
7819 taskq_req->dr_key_req.kr_key,
7820 &key)) != CRYPTO_SUCCESS)
7821 break;
7822 keyp = &key;
7823 }
7824
7825 /* get the software provider for this mechanism */
7826 if ((error = dprov_get_sw_prov(mechp, &pd,
7827 &mech.cm_type)) != CRYPTO_SUCCESS)
7828 break;
7829
7830 object_id = *taskq_req->dr_key_req.kr_object_id_ptr;
7831 if (object_id >= DPROV_MAX_OBJECTS) {
7832 error = CRYPTO_KEY_HANDLE_INVALID;
7833 break;
7834 }
7835
7836 /* get ptr to object */
7837 if ((object = session->ds_objects[object_id]) == NULL) {
7838 error = CRYPTO_OBJECT_HANDLE_INVALID;
7839 break;
7840 }
7841
7842 (void) dprov_get_object_attr_boolean(object,
7843 DPROV_CKA_EXTRACTABLE, &extractable);
7844
7845 if (!extractable) {
7846 error = CRYPTO_ATTRIBUTE_SENSITIVE;
7847 break;
7848 }
7849
7850 (void) dprov_get_object_attr_ulong(object,
7851 DPROV_CKA_CLASS, &class);
7852
7853 switch (class) {
7854 case DPROV_CKO_SECRET_KEY:
7855 object_idx = dprov_find_attr(object->do_attr,
7856 DPROV_MAX_ATTR, DPROV_CKA_VALUE);
7857 if (object_idx == -1) {
7858 error = CRYPTO_ATTRIBUTE_TYPE_INVALID;
7859 break;
7860 }
7861 break;
7862
7863 case DPROV_CKO_PRIVATE_KEY:
7864 /*
7865 * PKCS#11 says that ASN.1 should be used to encode
7866 * specific attributes before encrypting the blob.
7867 * We only encrypt the private exponent for the
7868 * purpose of testing.
7869 */
7870 object_idx = dprov_find_attr(object->do_attr,
7871 DPROV_MAX_ATTR, DPROV_CKA_PRIVATE_EXPONENT);
7872 if (object_idx == -1) {
7873 error = CRYPTO_ATTRIBUTE_TYPE_INVALID;
7874 break;
7875 }
7876 break;
7877 default:
7878 error = CRYPTO_KEY_NOT_WRAPPABLE;
7879 break;
7880 }
7881 if (error != CRYPTO_SUCCESS)
7882 break;
7883
7884 plaintext_key = object->do_attr[object_idx].oa_value;
7885 plaintext_key_len = object->do_attr[object_idx].oa_value_len;
7886 lenp = taskq_req->dr_key_req.kr_wrapped_key_len_ptr;
7887
7888 /* session id is 0 for software provider */
7889 plaintext.cd_format = CRYPTO_DATA_RAW;
7890 plaintext.cd_offset = 0;
7891 plaintext.cd_length = plaintext_key_len;
7892 plaintext.cd_raw.iov_base = plaintext_key;
7893 plaintext.cd_raw.iov_len = plaintext_key_len;
7894 plaintext.cd_miscdata = NULL;
7895
7896 ciphertext.cd_format = CRYPTO_DATA_RAW;
7897 ciphertext.cd_offset = 0;
7898 ciphertext.cd_length = *lenp;
7899 ciphertext.cd_raw.iov_base =
7900 (char *)taskq_req->dr_key_req.kr_wrapped_key;
7901 ciphertext.cd_raw.iov_len = ciphertext.cd_length;
7902 ciphertext.cd_miscdata = NULL;
7903
7904 error = crypto_encrypt_prov(pd, 0, &mech, &plaintext, keyp,
7905 NULL, &ciphertext, NULL);
7906
7907 KCF_PROV_REFRELE(pd);
7908 if (error == CRYPTO_SUCCESS ||
7909 error == CRYPTO_BUFFER_TOO_SMALL) {
7910 *lenp = ciphertext.cd_length;
7911 }
7912 break;
7913 }
7914
7915 case DPROV_REQ_KEY_UNWRAP: {
7916 crypto_mechanism_t mech, *mechp;
7917 crypto_key_t key, *keyp;
7918 crypto_object_id_t *object_id_ptr;
7919 ulong_t class = DPROV_CKO_DATA;
7920 uchar_t *wrapped_key;
7921 char *plaintext_buf;
7922 size_t wrapped_key_len;
7923 crypto_data_t plaintext;
7924 crypto_data_t ciphertext;
7925 crypto_object_attribute_t unwrapped_key;
7926 crypto_object_attribute_t *template;
7927 uint_t attribute_count;
7928
7929 template = taskq_req->dr_key_req.kr_template;
7930 attribute_count = taskq_req->dr_key_req.kr_attribute_count;
7931 object_id_ptr = taskq_req->dr_key_req.kr_object_id_ptr;
7932
7933 /* all objects must have an object class attribute */
7934 if (dprov_get_template_attr_ulong(template, attribute_count,
7935 DPROV_CKA_CLASS, &class) != CRYPTO_SUCCESS) {
7936 error = CRYPTO_TEMPLATE_INCOMPLETE;
7937 break;
7938 }
7939
7940 mechp = taskq_req->dr_key_req.kr_mechanism;
7941 /* structure assignment */
7942 mech = *mechp;
7943
7944 /* get unwrapping key value */
7945 if (is_publickey_mech(mech.cm_type)) {
7946 if ((error = dprov_key_attr_asymmetric(softc,
7947 session_id, taskq_req->dr_type,
7948 taskq_req->dr_key_req.kr_key,
7949 &key)) != CRYPTO_SUCCESS)
7950 break;
7951 keyp = &key;
7952 } else {
7953 if ((error = dprov_key_value_secret(softc,
7954 session_id, taskq_req->dr_type,
7955 taskq_req->dr_key_req.kr_key,
7956 &key)) != CRYPTO_SUCCESS)
7957 break;
7958 keyp = &key;
7959 }
7960
7961 /* get the software provider for this mechanism */
7962 if ((error = dprov_get_sw_prov(mechp, &pd,
7963 &mech.cm_type)) != CRYPTO_SUCCESS)
7964 break;
7965
7966 wrapped_key = taskq_req->dr_key_req.kr_wrapped_key;
7967 wrapped_key_len = *taskq_req->dr_key_req.kr_wrapped_key_len_ptr;
7968 ciphertext.cd_format = CRYPTO_DATA_RAW;
7969 ciphertext.cd_offset = 0;
7970 ciphertext.cd_length = wrapped_key_len;
7971 ciphertext.cd_raw.iov_base = (char *)wrapped_key;
7972 ciphertext.cd_raw.iov_len = wrapped_key_len;
7973 ciphertext.cd_miscdata = NULL;
7974
7975 /*
7976 * Plaintext length is less than or equal to
7977 * the length of the ciphertext.
7978 */
7979 plaintext_buf = kmem_alloc(wrapped_key_len, KM_SLEEP);
7980 plaintext.cd_format = CRYPTO_DATA_RAW;
7981 plaintext.cd_offset = 0;
7982 plaintext.cd_length = wrapped_key_len;
7983 plaintext.cd_raw.iov_base = plaintext_buf;
7984 plaintext.cd_raw.iov_len = wrapped_key_len;
7985 plaintext.cd_miscdata = NULL;
7986
7987 error = crypto_decrypt_prov(pd, 0, &mech, &ciphertext, keyp,
7988 NULL, &plaintext, NULL);
7989
7990 KCF_PROV_REFRELE(pd);
7991
7992 if (error != CRYPTO_SUCCESS)
7993 goto free_unwrapped_key;
7994
7995 error = dprov_create_object_from_template(softc, session,
7996 template, attribute_count, object_id_ptr, B_FALSE, B_FALSE);
7997
7998 if (error != CRYPTO_SUCCESS)
7999 goto free_unwrapped_key;
8000
8001 switch (class) {
8002 case DPROV_CKO_SECRET_KEY:
8003 unwrapped_key.oa_type = DPROV_CKA_VALUE;
8004 unwrapped_key.oa_value_len = plaintext.cd_length;
8005 unwrapped_key.oa_value = plaintext_buf;
8006 break;
8007 case DPROV_CKO_PRIVATE_KEY:
8008 /*
8009 * PKCS#11 says that ASN.1 should be used to encode
8010 * specific attributes before encrypting the blob.
8011 * We only encrypt the private exponent for the
8012 * purpose of testing.
8013 */
8014 unwrapped_key.oa_type = DPROV_CKA_PRIVATE_EXPONENT;
8015 unwrapped_key.oa_value_len = plaintext.cd_length;
8016 unwrapped_key.oa_value = plaintext_buf;
8017 break;
8018 default:
8019 error = CRYPTO_TEMPLATE_INCONSISTENT;
8020 goto free_unwrapped_key;
8021 }
8022
8023 if ((error = dprov_object_set_attr(session, *object_id_ptr,
8024 &unwrapped_key, 1, B_FALSE)) == CRYPTO_SUCCESS)
8025 break; /* don't free the unwrapped key */
8026
8027 /* failure */
8028 (void) dprov_destroy_object(softc, session, *object_id_ptr);
8029 break;
8030
8031 free_unwrapped_key:
8032 bzero(plaintext_buf, wrapped_key_len);
8033 kmem_free(plaintext_buf, wrapped_key_len);
8034 break;
8035 }
8036
8037 case DPROV_REQ_KEY_DERIVE: {
8038 crypto_mechanism_t digest_mech, *mechp;
8039 crypto_key_t key, *base_keyp;
8040 crypto_object_id_t *object_id_ptr;
8041 crypto_data_t data;
8042 crypto_data_t digest;
8043 size_t hash_size;
8044 char *digest_buf;
8045 crypto_object_attribute_t derived_key;
8046 crypto_object_attribute_t *template;
8047 uint_t attribute_count;
8048 ulong_t key_type;
8049 void *value;
8050 size_t value_len = 0;
8051
8052 error = CRYPTO_SUCCESS;
8053
8054 template = taskq_req->dr_key_req.kr_template;
8055 attribute_count = taskq_req->dr_key_req.kr_attribute_count;
8056 object_id_ptr = taskq_req->dr_key_req.kr_object_id_ptr;
8057
8058 /* required */
8059 if (dprov_get_template_attr_ulong(template, attribute_count,
8060 DPROV_CKA_KEY_TYPE, &key_type) != CRYPTO_SUCCESS) {
8061 error = CRYPTO_TEMPLATE_INCOMPLETE;
8062 break;
8063 }
8064
8065 mechp = taskq_req->dr_key_req.kr_mechanism;
8066 /* structure assignment */
8067 digest_mech = *mechp;
8068
8069 switch (digest_mech.cm_type) {
8070 case SHA1_KEY_DERIVATION_MECH_INFO_TYPE:
8071 hash_size = SHA1_DIGEST_LEN;
8072 digest_mech.cm_type = SHA1_MECH_INFO_TYPE;
8073 break;
8074
8075 case SHA256_KEY_DERIVATION_MECH_INFO_TYPE:
8076 hash_size = SHA256_DIGEST_LENGTH;
8077 digest_mech.cm_type = SHA256_MECH_INFO_TYPE;
8078 break;
8079
8080 case SHA384_KEY_DERIVATION_MECH_INFO_TYPE:
8081 hash_size = SHA384_DIGEST_LENGTH;
8082 digest_mech.cm_type = SHA384_MECH_INFO_TYPE;
8083 break;
8084
8085 case SHA512_KEY_DERIVATION_MECH_INFO_TYPE:
8086 hash_size = SHA512_DIGEST_LENGTH;
8087 digest_mech.cm_type = SHA512_MECH_INFO_TYPE;
8088 break;
8089
8090 case MD5_KEY_DERIVATION_MECH_INFO_TYPE:
8091 hash_size = MD5_DIGEST_LEN;
8092 digest_mech.cm_type = MD5_MECH_INFO_TYPE;
8093 break;
8094
8095 default:
8096 error = CRYPTO_MECHANISM_INVALID;
8097 }
8098
8099 if (error != CRYPTO_SUCCESS)
8100 break;
8101
8102 /* CKA_VALUE is optional */
8103 (void) dprov_get_template_attr_array(template, attribute_count,
8104 DPROV_CKA_VALUE, &value, &value_len);
8105
8106 /* check for inconsistent value length */
8107 switch (key_type) {
8108 case DPROV_CKK_GENERIC_SECRET:
8109 if (value_len > 0) {
8110 if (value_len > hash_size)
8111 error = CRYPTO_ATTRIBUTE_VALUE_INVALID;
8112 } else {
8113 value_len = hash_size;
8114 }
8115 break;
8116
8117 case DPROV_CKK_RC4:
8118 case DPROV_CKK_AES:
8119 if (value_len == 0 ||
8120 value_len > hash_size) {
8121 error = CRYPTO_ATTRIBUTE_VALUE_INVALID;
8122 }
8123 break;
8124
8125 case DPROV_CKK_DES:
8126 if (value_len > 0 &&
8127 value_len != DES_KEY_LEN) {
8128 error = CRYPTO_ATTRIBUTE_VALUE_INVALID;
8129 }
8130 value_len = DES_KEY_LEN;
8131 break;
8132
8133 case DPROV_CKK_DES3:
8134 if (value_len > 0 &&
8135 value_len != DES3_KEY_LEN) {
8136 error = CRYPTO_ATTRIBUTE_VALUE_INVALID;
8137 }
8138 value_len = DES3_KEY_LEN;
8139 break;
8140
8141 default:
8142 error = CRYPTO_ATTRIBUTE_VALUE_INVALID;
8143 break;
8144 }
8145
8146 if (error != CRYPTO_SUCCESS)
8147 break;
8148
8149 /* get the software provider for this mechanism */
8150 if ((error = dprov_get_sw_prov(&digest_mech, &pd,
8151 &digest_mech.cm_type)) != CRYPTO_SUCCESS)
8152 break;
8153
8154 /* get the base key */
8155 error = dprov_key_value_secret(softc, session_id,
8156 taskq_req->dr_type, taskq_req->dr_key_req.kr_key, &key);
8157 if (error != CRYPTO_SUCCESS)
8158 break;
8159
8160 base_keyp = &key;
8161
8162 data.cd_format = CRYPTO_DATA_RAW;
8163 data.cd_offset = 0;
8164 data.cd_length = CRYPTO_BITS2BYTES(base_keyp->ck_length);
8165 data.cd_raw.iov_base = base_keyp->ck_data;
8166 data.cd_raw.iov_len = data.cd_length;
8167
8168 digest_buf = kmem_alloc(hash_size, KM_SLEEP);
8169 digest.cd_format = CRYPTO_DATA_RAW;
8170 digest.cd_offset = 0;
8171 digest.cd_length = hash_size;
8172 digest.cd_raw.iov_base = digest_buf;
8173 digest.cd_raw.iov_len = hash_size;
8174
8175 error = crypto_digest_prov(pd, 0, &digest_mech, &data,
8176 &digest, NULL);
8177
8178 KCF_PROV_REFRELE(pd);
8179
8180 if (error != CRYPTO_SUCCESS)
8181 goto free_derived_key;
8182
8183 error = dprov_create_object_from_template(softc, session,
8184 template, attribute_count, object_id_ptr, B_FALSE, B_FALSE);
8185
8186 if (error != CRYPTO_SUCCESS)
8187 goto free_derived_key;
8188
8189 derived_key.oa_type = DPROV_CKA_VALUE;
8190 derived_key.oa_value = digest_buf;
8191 derived_key.oa_value_len = value_len;
8192
8193 error = dprov_object_set_attr(session, *object_id_ptr,
8194 &derived_key, 1, B_FALSE);
8195
8196 if (error != CRYPTO_SUCCESS) {
8197 (void) dprov_destroy_object(softc, session,
8198 *object_id_ptr);
8199 }
8200
8201 free_derived_key:
8202 bzero(digest_buf, hash_size);
8203 kmem_free(digest_buf, hash_size);
8204 break;
8205 }
8206
8207 case DPROV_REQ_NOSTORE_KEY_GENERATE: {
8208 crypto_object_attribute_t *out_template;
8209 uint_t out_attribute_count;
8210 void *value;
8211 size_t value_len = 0;
8212
8213 out_template = taskq_req->dr_key_req.kr_out_template1;
8214 out_attribute_count =
8215 taskq_req->dr_key_req.kr_out_attribute_count1;
8216
8217 error = dprov_get_template_attr_array(out_template,
8218 out_attribute_count, DPROV_CKA_VALUE, &value, &value_len);
8219 if (error != CRYPTO_SUCCESS)
8220 break;
8221
8222 /* fill the entire array with pattern */
8223 {
8224 int i = 0;
8225 char *p = value;
8226 while (i < value_len) {
8227 p[i++] = 'A';
8228 if (i >= value_len)
8229 break;
8230 p[i++] = 'B';
8231 if (i >= value_len)
8232 break;
8233 p[i++] = 'C';
8234 }
8235 }
8236
8237 error = CRYPTO_SUCCESS;
8238 break;
8239 }
8240
8241 case DPROV_REQ_NOSTORE_KEY_GENERATE_PAIR: {
8242 crypto_mechanism_t *mechp;
8243 crypto_object_attribute_t *pub_template;
8244 crypto_object_attribute_t *pri_template;
8245 uint_t pub_attribute_count;
8246 uint_t pri_attribute_count;
8247 crypto_object_attribute_t *out_pub_template;
8248 crypto_object_attribute_t *out_pri_template;
8249 uint_t out_pub_attribute_count;
8250 uint_t out_pri_attribute_count;
8251
8252 mechp = taskq_req->dr_key_req.kr_mechanism;
8253 pub_template = taskq_req->dr_key_req.kr_template;
8254 pub_attribute_count = taskq_req->dr_key_req.kr_attribute_count;
8255 pri_template = taskq_req->dr_key_req.kr_private_key_template;
8256 pri_attribute_count =
8257 taskq_req->dr_key_req.kr_private_key_attribute_count;
8258 out_pub_template = taskq_req->dr_key_req.kr_out_template1;
8259 out_pub_attribute_count =
8260 taskq_req->dr_key_req.kr_out_attribute_count1;
8261 out_pri_template = taskq_req->dr_key_req.kr_out_template2;
8262 out_pri_attribute_count =
8263 taskq_req->dr_key_req.kr_out_attribute_count2;
8264
8265 switch (mechp->cm_type) {
8266 case RSA_PKCS_KEY_PAIR_GEN_MECH_INFO_TYPE:
8267 error = nostore_copy_attribute(out_pub_template,
8268 out_pub_attribute_count, DPROV_CKA_MODULUS);
8269 if (error != CRYPTO_SUCCESS)
8270 break;
8271
8272 error = nostore_copy_attribute(out_pub_template,
8273 out_pub_attribute_count, DPROV_CKA_PUBLIC_EXPONENT);
8274 if (error == CRYPTO_ARGUMENTS_BAD) {
8275 size_t tmp_len = 0;
8276 void *tmp;
8277
8278 /* public exponent must be here */
8279 error = dprov_get_template_attr_array(
8280 pub_template, pub_attribute_count,
8281 DPROV_CKA_PUBLIC_EXPONENT, &tmp, &tmp_len);
8282 if (error != CRYPTO_SUCCESS)
8283 break;
8284 }
8285 error = nostore_copy_attribute(out_pri_template,
8286 out_pri_attribute_count, DPROV_CKA_MODULUS);
8287 if (error != CRYPTO_SUCCESS)
8288 break;
8289
8290 error = nostore_copy_attribute(out_pri_template,
8291 out_pri_attribute_count,
8292 DPROV_CKA_PRIVATE_EXPONENT);
8293 break;
8294
8295 case DH_PKCS_KEY_PAIR_GEN_MECH_INFO_TYPE:
8296 /*
8297 * There is no software provider for DH mechanism;
8298 * Just return pre-defined values.
8299 */
8300 error = nostore_copy_attribute(out_pub_template,
8301 out_pub_attribute_count, DPROV_CKA_VALUE);
8302 error = nostore_copy_attribute(out_pri_template,
8303 out_pri_attribute_count, DPROV_CKA_VALUE);
8304 break;
8305
8306 case EC_KEY_PAIR_GEN_MECH_INFO_TYPE: {
8307 crypto_mechanism_t mech, *mechp;
8308 kcf_req_params_t params;
8309 crypto_object_attribute_t *pub_template;
8310 uint_t pub_attribute_count;
8311 crypto_object_attribute_t *out_pub_template;
8312 crypto_object_attribute_t *out_pri_template;
8313 uint_t out_pub_attribute_count;
8314 uint_t out_pri_attribute_count;
8315
8316 mechp = taskq_req->dr_key_req.kr_mechanism;
8317 pub_template = taskq_req->dr_key_req.kr_template;
8318 pub_attribute_count =
8319 taskq_req->dr_key_req.kr_attribute_count;
8320 out_pub_template =
8321 taskq_req->dr_key_req.kr_out_template1;
8322 out_pub_attribute_count =
8323 taskq_req->dr_key_req.kr_out_attribute_count1;
8324 out_pri_template =
8325 taskq_req->dr_key_req.kr_out_template2;
8326 out_pri_attribute_count =
8327 taskq_req->dr_key_req.kr_out_attribute_count2;
8328
8329 /* get the software provider for this mechanism */
8330 mech = *mechp;
8331 if ((error = dprov_get_sw_prov(mechp, &pd,
8332 &mech.cm_type)) != CRYPTO_SUCCESS)
8333 break;
8334 /*
8335 * Turn 32-bit values into 64-bit values for certain
8336 * attributes like CKA_CLASS.
8337 */
8338 dprov_adjust_attrs(pub_template, pub_attribute_count);
8339 dprov_adjust_attrs(pri_template, pri_attribute_count);
8340
8341 /* bypass the kernel API for now */
8342 KCF_WRAP_NOSTORE_KEY_OPS_PARAMS(¶ms,
8343 KCF_OP_KEY_GENERATE_PAIR,
8344 0, /* session 0 for sw provider */
8345 &mech, pub_template, pub_attribute_count,
8346 pri_template, pri_attribute_count, NULL,
8347 out_pub_template, out_pub_attribute_count,
8348 out_pri_template, out_pri_attribute_count);
8349
8350 error = kcf_submit_request(pd, NULL, NULL, ¶ms,
8351 B_FALSE);
8352
8353 KCF_PROV_REFRELE(pd);
8354 break;
8355 }
8356 default:
8357 error = CRYPTO_MECHANISM_INVALID;
8358 }
8359 break;
8360 }
8361
8362 case DPROV_REQ_NOSTORE_KEY_DERIVE: {
8363 crypto_mechanism_t *mechp;
8364 crypto_object_attribute_t *in_template, *out_template;
8365 crypto_key_t *base_key;
8366 uint_t in_attribute_count, out_attribute_count;
8367 ulong_t key_type;
8368 void *value;
8369 size_t value_len = 0;
8370 size_t value_len_value = 0;
8371
8372 in_template = taskq_req->dr_key_req.kr_template;
8373 out_template = taskq_req->dr_key_req.kr_out_template1;
8374 in_attribute_count = taskq_req->dr_key_req.kr_attribute_count;
8375 out_attribute_count =
8376 taskq_req->dr_key_req.kr_out_attribute_count1;
8377 mechp = taskq_req->dr_key_req.kr_mechanism;
8378 base_key = taskq_req->dr_key_req.kr_key;
8379
8380 /*
8381 * CKA_VALUE must be present so the derived key can
8382 * be returned by value.
8383 */
8384 if (dprov_get_template_attr_array(out_template,
8385 out_attribute_count, DPROV_CKA_VALUE, &value,
8386 &value_len) != CRYPTO_SUCCESS) {
8387 error = CRYPTO_TEMPLATE_INCOMPLETE;
8388 break;
8389 }
8390
8391 if (dprov_get_template_attr_ulong(in_template,
8392 in_attribute_count, DPROV_CKA_KEY_TYPE,
8393 &key_type) != CRYPTO_SUCCESS) {
8394 error = CRYPTO_TEMPLATE_INCOMPLETE;
8395 break;
8396 }
8397 switch (mechp->cm_type) {
8398 case DH_PKCS_DERIVE_MECH_INFO_TYPE: {
8399 size_t tmp_len = 0;
8400 void *tmp;
8401
8402 if (base_key->ck_format != CRYPTO_KEY_ATTR_LIST) {
8403 error = CRYPTO_ARGUMENTS_BAD;
8404 break;
8405 }
8406
8407 if ((dprov_get_template_attr_array(base_key->ck_attrs,
8408 base_key->ck_count, DPROV_CKA_BASE, &tmp,
8409 &tmp_len) != CRYPTO_SUCCESS) ||
8410 (dprov_get_template_attr_array(base_key->ck_attrs,
8411 base_key->ck_count, DPROV_CKA_PRIME, &tmp,
8412 &tmp_len) != CRYPTO_SUCCESS) ||
8413 (dprov_get_template_attr_array(base_key->ck_attrs,
8414 base_key->ck_count, DPROV_CKA_VALUE, &tmp,
8415 &tmp_len) != CRYPTO_SUCCESS)) {
8416 error = CRYPTO_TEMPLATE_INCOMPLETE;
8417 break;
8418 }
8419
8420 /*
8421 * CKA_VALUE is added to the derived key template by
8422 * the library.
8423 */
8424 error = CRYPTO_SUCCESS;
8425 switch (key_type) {
8426 case DPROV_CKK_AES:
8427 if (dprov_get_template_attr_ulong(in_template,
8428 in_attribute_count, DPROV_CKA_VALUE_LEN,
8429 &value_len_value) != CRYPTO_SUCCESS) {
8430 error = CRYPTO_TEMPLATE_INCOMPLETE;
8431 break;
8432 }
8433 if (value_len != value_len_value) {
8434 error = CRYPTO_TEMPLATE_INCONSISTENT;
8435 break;
8436 }
8437 default:
8438 error = CRYPTO_MECHANISM_INVALID;
8439 }
8440 if (error == CRYPTO_SUCCESS)
8441 fill_dh(value, value_len);
8442 break;
8443 }
8444 case ECDH1_DERIVE_MECH_INFO_TYPE: {
8445 crypto_mechanism_t mech;
8446 kcf_req_params_t params;
8447
8448 /* get the software provider for this mechanism */
8449 mech = *mechp;
8450 if ((error = dprov_get_sw_prov(mechp, &pd,
8451 &mech.cm_type)) != CRYPTO_SUCCESS)
8452 break;
8453
8454 /*
8455 * Turn 32-bit values into 64-bit values for certain
8456 * attributes like CKA_VALUE_LEN.
8457 */
8458 dprov_adjust_attrs(in_template, in_attribute_count);
8459
8460 /* bypass the kernel API for now */
8461 KCF_WRAP_NOSTORE_KEY_OPS_PARAMS(¶ms,
8462 KCF_OP_KEY_DERIVE,
8463 0, /* session 0 for sw provider */
8464 &mech, in_template, in_attribute_count,
8465 NULL, 0, base_key,
8466 out_template, out_attribute_count,
8467 NULL, 0);
8468
8469 error = kcf_submit_request(pd, NULL, NULL, ¶ms,
8470 B_FALSE);
8471
8472 KCF_PROV_REFRELE(pd);
8473 break;
8474 }
8475
8476 default:
8477 error = CRYPTO_MECHANISM_INVALID;
8478 }
8479 break;
8480 default:
8481 error = CRYPTO_MECHANISM_INVALID;
8482 }
8483 } /* end case */
8484
8485 mutex_exit(&softc->ds_lock);
8486 dprov_op_done(taskq_req, error);
8487 DPROV_DEBUG(D_KEY, ("(%d) dprov_key_task: end\n", instance));
8488 }
8489
8490 /*
8491 * taskq dispatcher function for provider management operations.
8492 */
8493 static void
8494 dprov_mgmt_task(dprov_req_t *taskq_req)
8495 {
8496 dprov_state_t *softc;
8497 /* LINTED E_FUNC_SET_NOT_USED */
8498 int instance;
8499 int error = CRYPTO_NOT_SUPPORTED;
8500
8501 DPROV_SOFTC_FROM_REQ(taskq_req, softc, instance);
8502 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_mgmt_task: started\n", instance));
8503
8504 mutex_enter(&softc->ds_lock);
8505
8506 switch (taskq_req->dr_type) {
8507 case DPROV_REQ_MGMT_EXTINFO: {
8508 crypto_provider_ext_info_t *ext_info =
8509 taskq_req->dr_mgmt_req.mr_ext_info;
8510
8511 (void) memset(ext_info->ei_label, ' ', CRYPTO_EXT_SIZE_LABEL);
8512 if (!softc->ds_token_initialized) {
8513 bcopy("(not initialized)", ext_info->ei_label,
8514 strlen("(not initialized)"));
8515 } else {
8516 bcopy(softc->ds_label, ext_info->ei_label,
8517 CRYPTO_EXT_SIZE_LABEL);
8518 }
8519
8520 bcopy(DPROV_MANUFACTURER, ext_info->ei_manufacturerID,
8521 CRYPTO_EXT_SIZE_MANUF);
8522 bcopy(DPROV_MODEL, ext_info->ei_model, CRYPTO_EXT_SIZE_MODEL);
8523
8524 (void) snprintf((char *)ext_info->ei_serial_number, 16, "%d%s",
8525 instance, DPROV_ALLSPACES);
8526 /* PKCS#11 blank padding */
8527 ext_info->ei_serial_number[15] = ' ';
8528 ext_info->ei_max_session_count = CRYPTO_EFFECTIVELY_INFINITE;
8529 ext_info->ei_max_pin_len = (ulong_t)DPROV_MAX_PIN_LEN;
8530 ext_info->ei_min_pin_len = 1;
8531 ext_info->ei_total_public_memory = CRYPTO_EFFECTIVELY_INFINITE;
8532 ext_info->ei_free_public_memory = CRYPTO_EFFECTIVELY_INFINITE;
8533 ext_info->ei_total_private_memory = CRYPTO_EFFECTIVELY_INFINITE;
8534 ext_info->ei_free_private_memory = CRYPTO_EFFECTIVELY_INFINITE;
8535 ext_info->ei_hardware_version.cv_major = 1;
8536 ext_info->ei_hardware_version.cv_minor = 0;
8537 ext_info->ei_firmware_version.cv_major = 1;
8538 ext_info->ei_firmware_version.cv_minor = 0;
8539
8540 ext_info->ei_flags = CRYPTO_EXTF_RNG |
8541 CRYPTO_EXTF_LOGIN_REQUIRED |
8542 CRYPTO_EXTF_DUAL_CRYPTO_OPERATIONS;
8543 if (softc->ds_user_pin_set)
8544 ext_info->ei_flags |= CRYPTO_EXTF_USER_PIN_INITIALIZED;
8545 if (softc->ds_token_initialized)
8546 ext_info->ei_flags |= CRYPTO_EXTF_TOKEN_INITIALIZED;
8547
8548 ext_info->ei_hash_max_input_len = dprov_max_digestsz;
8549 ext_info->ei_hmac_max_input_len = dprov_max_digestsz;
8550 error = CRYPTO_SUCCESS;
8551 break;
8552 }
8553 case DPROV_REQ_MGMT_INITTOKEN: {
8554 char *pin = taskq_req->dr_mgmt_req.mr_pin;
8555 size_t pin_len = taskq_req->dr_mgmt_req.mr_pin_len;
8556 char *label = taskq_req->dr_mgmt_req.mr_label;
8557
8558 /* cannot initialize token when a session is open */
8559 if (softc->ds_sessions_count > 0) {
8560 error = CRYPTO_SESSION_EXISTS;
8561 break;
8562 }
8563
8564 /* check PIN length */
8565 if (pin_len > DPROV_MAX_PIN_LEN) {
8566 error = CRYPTO_PIN_LEN_RANGE;
8567 break;
8568 }
8569
8570 /* check PIN */
8571 if (pin == NULL) {
8572 error = CRYPTO_PIN_INVALID;
8573 break;
8574 }
8575
8576 /*
8577 * If the token has already been initialized, need
8578 * to validate supplied PIN.
8579 */
8580 if (softc->ds_token_initialized &&
8581 (softc->ds_so_pin_len != pin_len ||
8582 strncmp(softc->ds_so_pin, pin, pin_len) != 0)) {
8583 /* invalid SO PIN */
8584 error = CRYPTO_PIN_INCORRECT;
8585 break;
8586 }
8587
8588 /* set label */
8589 bcopy(label, softc->ds_label, CRYPTO_EXT_SIZE_LABEL);
8590
8591 /* set new SO PIN, update state */
8592 bcopy(pin, softc->ds_so_pin, pin_len);
8593 softc->ds_so_pin_len = pin_len;
8594 softc->ds_token_initialized = B_TRUE;
8595 softc->ds_user_pin_set = B_FALSE;
8596
8597 error = CRYPTO_SUCCESS;
8598 break;
8599 }
8600 case DPROV_REQ_MGMT_INITPIN: {
8601 char *pin = taskq_req->dr_mgmt_req.mr_pin;
8602 size_t pin_len = taskq_req->dr_mgmt_req.mr_pin_len;
8603 crypto_session_id_t session_id =
8604 taskq_req->dr_mgmt_req.mr_session_id;
8605
8606 /* check session id */
8607 if (softc->ds_sessions[session_id] == NULL) {
8608 error = CRYPTO_SESSION_HANDLE_INVALID;
8609 break;
8610 }
8611
8612 /* fail if not logged in as SO */
8613 if (softc->ds_sessions[session_id]->ds_state !=
8614 DPROV_SESSION_STATE_SO) {
8615 error = CRYPTO_USER_NOT_LOGGED_IN;
8616 break;
8617 }
8618
8619 /* check PIN length */
8620 if (pin_len > DPROV_MAX_PIN_LEN) {
8621 error = CRYPTO_PIN_LEN_RANGE;
8622 break;
8623 }
8624
8625 /* check PIN */
8626 if (pin == NULL) {
8627 error = CRYPTO_PIN_INVALID;
8628 break;
8629 }
8630
8631 /* set new normal user PIN */
8632 bcopy(pin, softc->ds_user_pin, pin_len);
8633 softc->ds_user_pin_len = pin_len;
8634 softc->ds_user_pin_set = B_TRUE;
8635
8636 error = CRYPTO_SUCCESS;
8637 break;
8638 }
8639 case DPROV_REQ_MGMT_SETPIN: {
8640 char *new_pin = taskq_req->dr_mgmt_req.mr_pin;
8641 size_t new_pin_len = taskq_req->dr_mgmt_req.mr_pin_len;
8642 char *old_pin = taskq_req->dr_mgmt_req.mr_old_pin;
8643 size_t old_pin_len = taskq_req->dr_mgmt_req.mr_old_pin_len;
8644 crypto_session_id_t session_id =
8645 taskq_req->dr_mgmt_req.mr_session_id;
8646
8647 /* check session id */
8648 if (softc->ds_sessions[session_id] == NULL) {
8649 error = CRYPTO_SESSION_HANDLE_INVALID;
8650 break;
8651 }
8652
8653 /* check PIN length */
8654 if (old_pin_len > DPROV_MAX_PIN_LEN ||
8655 new_pin_len > DPROV_MAX_PIN_LEN) {
8656 error = CRYPTO_PIN_LEN_RANGE;
8657 break;
8658 }
8659
8660 /* check PIN */
8661 if (old_pin == NULL || new_pin == NULL) {
8662 error = CRYPTO_PIN_INVALID;
8663 break;
8664 }
8665
8666 /* check user PIN state */
8667 if (!softc->ds_user_pin_set) {
8668 error = CRYPTO_USER_PIN_NOT_INITIALIZED;
8669 break;
8670 }
8671
8672 /*
8673 * If the token has already been initialized, need
8674 * to validate supplied PIN.
8675 */
8676 if (softc->ds_user_pin_len != old_pin_len ||
8677 strncmp(softc->ds_user_pin, old_pin, old_pin_len) != 0) {
8678 /* invalid SO PIN */
8679 error = CRYPTO_PIN_INCORRECT;
8680 break;
8681 }
8682
8683 /* set new PIN */
8684 bcopy(new_pin, softc->ds_user_pin, new_pin_len);
8685 softc->ds_user_pin_len = new_pin_len;
8686
8687 error = CRYPTO_SUCCESS;
8688 break;
8689 }
8690 }
8691
8692 mutex_exit(&softc->ds_lock);
8693 dprov_op_done(taskq_req, error);
8694 DPROV_DEBUG(D_DIGEST, ("(%d) dprov_mgmt_task: end\n", instance));
8695 }
8696
8697 /*
8698 * Returns in the location pointed to by pd a pointer to the descriptor
8699 * for the software provider for the specified mechanism.
8700 * The provider descriptor is returned held. Returns one of the CRYPTO_
8701 * error codes on failure, CRYPTO_SUCCESS on success.
8702 */
8703 static int
8704 dprov_get_sw_prov(crypto_mechanism_t *mech, kcf_provider_desc_t **pd,
8705 crypto_mech_type_t *provider_mech_type)
8706 {
8707 crypto_mech_type_t kcf_mech_type = CRYPTO_MECH_INVALID;
8708 int i, rv;
8709
8710 /* lookup the KCF mech type associated with our mech type */
8711 for (i = 0; i < sizeof (dprov_mech_info_tab)/
8712 sizeof (crypto_mech_info_t); i++) {
8713 if (mech->cm_type == dprov_mech_info_tab[i].cm_mech_number) {
8714 kcf_mech_type = crypto_mech2id_common(
8715 dprov_mech_info_tab[i].cm_mech_name, B_TRUE);
8716 }
8717 }
8718
8719 rv = kcf_get_sw_prov(kcf_mech_type, pd, NULL, B_TRUE);
8720 if (rv == CRYPTO_SUCCESS)
8721 *provider_mech_type = kcf_mech_type;
8722
8723 return (rv);
8724 }
8725
8726 /*
8727 * Object management helper functions.
8728 */
8729
8730 /*
8731 * Given a crypto_key_t, return whether the key can be used or not
8732 * for the specified request. The attributes used here are defined
8733 * in table 42 of the PKCS#11 spec (Common secret key attributes).
8734 */
8735 static int
8736 dprov_key_can_use(dprov_object_t *object, dprov_req_type_t req_type)
8737 {
8738 boolean_t ret = 0;
8739 int rv = CRYPTO_SUCCESS;
8740
8741 /* check if object is allowed for specified operation */
8742 switch (req_type) {
8743 case DPROV_REQ_ENCRYPT_INIT:
8744 case DPROV_REQ_ENCRYPT_ATOMIC:
8745 rv = dprov_get_object_attr_boolean(object,
8746 DPROV_CKA_ENCRYPT, &ret);
8747 break;
8748 case DPROV_REQ_DECRYPT_INIT:
8749 case DPROV_REQ_DECRYPT_ATOMIC:
8750 rv = dprov_get_object_attr_boolean(object,
8751 DPROV_CKA_DECRYPT, &ret);
8752 break;
8753 case DPROV_REQ_SIGN_INIT:
8754 case DPROV_REQ_SIGN_ATOMIC:
8755 case DPROV_REQ_MAC_INIT:
8756 case DPROV_REQ_MAC_ATOMIC:
8757 case DPROV_REQ_MAC_VERIFY_ATOMIC:
8758 rv = dprov_get_object_attr_boolean(object,
8759 DPROV_CKA_SIGN, &ret);
8760 break;
8761 case DPROV_REQ_SIGN_RECOVER_INIT:
8762 case DPROV_REQ_SIGN_RECOVER_ATOMIC:
8763 rv = dprov_get_object_attr_boolean(object,
8764 DPROV_CKA_SIGN_RECOVER, &ret);
8765 break;
8766 case DPROV_REQ_VERIFY_INIT:
8767 case DPROV_REQ_VERIFY_ATOMIC:
8768 rv = dprov_get_object_attr_boolean(object,
8769 DPROV_CKA_VERIFY, &ret);
8770 break;
8771 case DPROV_REQ_VERIFY_RECOVER_INIT:
8772 case DPROV_REQ_VERIFY_RECOVER_ATOMIC:
8773 rv = dprov_get_object_attr_boolean(object,
8774 DPROV_CKA_VERIFY_RECOVER, &ret);
8775 break;
8776 case DPROV_REQ_KEY_WRAP:
8777 rv = dprov_get_object_attr_boolean(object,
8778 DPROV_CKA_WRAP, &ret);
8779 break;
8780 case DPROV_REQ_KEY_UNWRAP:
8781 rv = dprov_get_object_attr_boolean(object,
8782 DPROV_CKA_UNWRAP, &ret);
8783 break;
8784 case DPROV_REQ_DIGEST_KEY:
8785 /*
8786 * There is no attribute to check for; therefore,
8787 * any secret key can be used.
8788 */
8789 ret = B_TRUE;
8790 rv = CRYPTO_SUCCESS;
8791 break;
8792 case DPROV_REQ_KEY_DERIVE:
8793 rv = dprov_get_object_attr_boolean(object,
8794 DPROV_CKA_DERIVE, &ret);
8795 break;
8796 }
8797
8798 if (rv != CRYPTO_SUCCESS || !ret)
8799 return (CRYPTO_KEY_FUNCTION_NOT_PERMITTED);
8800
8801 return (CRYPTO_SUCCESS);
8802 }
8803
8804 /*
8805 * Given a crypto_key_t corresponding to a secret key (i.e. for
8806 * use with symmetric crypto algorithms) specified in raw format, by
8807 * attribute, or by reference, initialize the ck_data and ck_length
8808 * fields of the ret_key argument so that they specify the key value
8809 * and length.
8810 *
8811 * For a key by value, this function uess the ck_data and ck_length,
8812 * for a key by reference, it looks up the corresponding object and
8813 * returns the appropriate attribute. For a key by attribute, it returns
8814 * the appropriate attribute. The attributes used are CKA_VALUE to retrieve
8815 * the value of the key, and CKA_VALUE_LEN to retrieve its length in bytes.
8816 */
8817 static int
8818 dprov_key_value_secret(dprov_state_t *softc, crypto_session_id_t session_id,
8819 dprov_req_type_t req_type, crypto_key_t *key, crypto_key_t *ret_key)
8820 {
8821 ulong_t key_type;
8822 int ret = CRYPTO_SUCCESS;
8823
8824 ret_key->ck_format = CRYPTO_KEY_RAW;
8825
8826 switch (key->ck_format) {
8827
8828 case CRYPTO_KEY_RAW:
8829 ret_key->ck_data = key->ck_data;
8830 ret_key->ck_length = key->ck_length;
8831 break;
8832
8833 case CRYPTO_KEY_ATTR_LIST: {
8834 void *value;
8835 size_t len, value_len;
8836
8837 if ((ret = dprov_get_key_attr_ulong(key, DPROV_CKA_KEY_TYPE,
8838 &key_type)) != CRYPTO_SUCCESS)
8839 break;
8840
8841 if ((ret = dprov_get_key_attr_array(key, DPROV_CKA_VALUE,
8842 &value, &len)) != CRYPTO_SUCCESS)
8843 break;
8844
8845 /*
8846 * The length of the array is expressed in bytes.
8847 * Convert to bits now since that's how keys are measured.
8848 */
8849 len = CRYPTO_BYTES2BITS(len);
8850
8851 /* optional */
8852 if ((dprov_get_key_attr_ulong(key, DPROV_CKA_VALUE_LEN,
8853 &value_len)) == CRYPTO_SUCCESS) {
8854 len = value_len;
8855 }
8856
8857 ret_key->ck_data = value;
8858 ret_key->ck_length = (uint_t)len;
8859
8860 break;
8861 }
8862
8863 case CRYPTO_KEY_REFERENCE: {
8864 dprov_object_t *object;
8865 void *value;
8866 size_t len, value_len;
8867
8868 /* check session id */
8869 if (softc->ds_sessions[session_id] == NULL) {
8870 ret = CRYPTO_SESSION_HANDLE_INVALID;
8871 break;
8872 }
8873
8874 if (key->ck_obj_id >= DPROV_MAX_OBJECTS) {
8875 ret = CRYPTO_KEY_HANDLE_INVALID;
8876 goto bail;
8877 }
8878
8879 /* check if object id specified by key is valid */
8880 object = softc->ds_sessions[session_id]->
8881 ds_objects[key->ck_obj_id];
8882 if (object == NULL) {
8883 ret = CRYPTO_KEY_HANDLE_INVALID;
8884 goto bail;
8885 }
8886
8887 /* check if object can be used for operation */
8888 if ((ret = dprov_key_can_use(object, req_type)) !=
8889 CRYPTO_SUCCESS)
8890 goto bail;
8891
8892 if ((ret = dprov_get_object_attr_ulong(object,
8893 DPROV_CKA_KEY_TYPE, &key_type)) != CRYPTO_SUCCESS)
8894 goto bail;
8895
8896 if ((ret = dprov_get_object_attr_array(object,
8897 DPROV_CKA_VALUE, &value, &len)) != CRYPTO_SUCCESS)
8898 goto bail;
8899
8900 /* optional */
8901 if ((dprov_get_object_attr_ulong(object, DPROV_CKA_VALUE_LEN,
8902 &value_len)) == CRYPTO_SUCCESS) {
8903 len = value_len;
8904 }
8905
8906 /*
8907 * The length of attributes are in bytes.
8908 * Convert to bits now since that's how keys are measured.
8909 */
8910 len = CRYPTO_BYTES2BITS(len);
8911
8912 ret_key->ck_data = value;
8913 ret_key->ck_length = (uint_t)len;
8914 bail:
8915 break;
8916 }
8917
8918 default:
8919 ret = CRYPTO_ARGUMENTS_BAD;
8920 break;
8921 }
8922
8923 return (ret);
8924 }
8925
8926 /*
8927 * Get the attribute list for the specified asymmetric key.
8928 */
8929 static int
8930 dprov_key_attr_asymmetric(dprov_state_t *softc, crypto_session_id_t session_id,
8931 dprov_req_type_t req_type, crypto_key_t *key, crypto_key_t *ret_key)
8932 {
8933 int ret = CRYPTO_SUCCESS;
8934
8935 ret_key->ck_format = CRYPTO_KEY_ATTR_LIST;
8936
8937 switch (key->ck_format) {
8938
8939 case CRYPTO_KEY_ATTR_LIST:
8940 ret_key->ck_attrs = key->ck_attrs;
8941 ret_key->ck_count = key->ck_count;
8942 break;
8943
8944 case CRYPTO_KEY_REFERENCE: {
8945 dprov_object_t *object;
8946
8947 /* check session id */
8948 if (softc->ds_sessions[session_id] == NULL) {
8949 ret = CRYPTO_SESSION_HANDLE_INVALID;
8950 break;
8951 }
8952
8953 /* check if object id specified by key is valid */
8954 object = softc->ds_sessions[session_id]->
8955 ds_objects[key->ck_obj_id];
8956 if (object == NULL) {
8957 ret = CRYPTO_KEY_HANDLE_INVALID;
8958 break;
8959 }
8960
8961 /* check if object can be used for operation */
8962 if ((ret = dprov_key_can_use(object, req_type)) !=
8963 CRYPTO_SUCCESS)
8964 break;
8965
8966 ret_key->ck_attrs = object->do_attr;
8967 ret_key->ck_count = DPROV_MAX_ATTR;
8968 break;
8969 }
8970
8971 default:
8972 ret = CRYPTO_ARGUMENTS_BAD;
8973 }
8974
8975 return (ret);
8976 }
8977
8978 /*
8979 * Return the index of an attribute of specified type found in
8980 * the specified array of attributes. If the attribute cannot
8981 * found, return -1.
8982 */
8983 static int
8984 dprov_find_attr(crypto_object_attribute_t *attr, uint_t nattr,
8985 uint64_t attr_type)
8986 {
8987 int i;
8988
8989 for (i = 0; i < nattr; i++)
8990 if (attr[i].oa_value != NULL &&
8991 attr[i].oa_type == attr_type)
8992 return (i);
8993
8994 return (-1);
8995 }
8996
8997 /*
8998 * Given the given object template and session, return whether
8999 * an object can be created from that template according to the
9000 * following rules:
9001 * - private objects can be created only by a logged-in user
9002 */
9003 static int
9004 dprov_template_can_create(dprov_session_t *session,
9005 crypto_object_attribute_t *template, uint_t nattr,
9006 boolean_t check_for_secret)
9007 {
9008 boolean_t is_private = B_FALSE;
9009 ulong_t key_type, class;
9010 int error;
9011
9012 /* check CKA_PRIVATE attribute value */
9013 error = dprov_get_template_attr_boolean(template, nattr,
9014 DPROV_CKA_PRIVATE, &is_private);
9015 if (error == CRYPTO_SUCCESS && is_private) {
9016 /* it's a private object */
9017 if (session->ds_state != DPROV_SESSION_STATE_USER) {
9018 /*
9019 * Cannot create private object with SO or public
9020 * sessions.
9021 */
9022 return (CRYPTO_ATTRIBUTE_VALUE_INVALID);
9023 }
9024 }
9025
9026 /* all objects must have an object class attribute */
9027 if (dprov_get_template_attr_ulong(template, nattr, DPROV_CKA_CLASS,
9028 &class) != CRYPTO_SUCCESS) {
9029 return (CRYPTO_TEMPLATE_INCOMPLETE);
9030 }
9031
9032 /* key objects must have a key type attribute */
9033 if (class == DPROV_CKO_SECRET_KEY ||
9034 class == DPROV_CKO_PUBLIC_KEY ||
9035 class == DPROV_CKO_PRIVATE_KEY) {
9036 if (!dprov_template_attr_present(template, nattr,
9037 DPROV_CKA_KEY_TYPE)) {
9038 return (CRYPTO_TEMPLATE_INCOMPLETE);
9039 }
9040 }
9041
9042 /* check for RSA public key attributes that must be present */
9043 if (class == DPROV_CKO_PUBLIC_KEY) {
9044 if (dprov_get_template_attr_ulong(template, nattr,
9045 DPROV_CKA_KEY_TYPE, &key_type) == CRYPTO_SUCCESS) {
9046 if (key_type == DPROV_CKK_RSA) {
9047 if (!dprov_template_attr_present(template,
9048 nattr, DPROV_CKA_MODULUS) ||
9049 !dprov_template_attr_present(template,
9050 nattr, DPROV_CKA_PUBLIC_EXPONENT)) {
9051 return (CRYPTO_TEMPLATE_INCOMPLETE);
9052 }
9053
9054 /* these attributes should not be present */
9055 if (dprov_template_attr_present(template, nattr,
9056 DPROV_CKA_MODULUS_BITS)) {
9057 return (CRYPTO_TEMPLATE_INCONSISTENT);
9058 }
9059 }
9060 }
9061 }
9062
9063 /* check for RSA private key attributes that must be present */
9064 if (class == DPROV_CKO_PRIVATE_KEY) {
9065 if (dprov_get_template_attr_ulong(template, nattr,
9066 DPROV_CKA_KEY_TYPE, &key_type) == CRYPTO_SUCCESS) {
9067 if (key_type == DPROV_CKK_RSA) {
9068 if (!dprov_template_attr_present(template,
9069 nattr, DPROV_CKA_MODULUS))
9070 return (CRYPTO_TEMPLATE_INCOMPLETE);
9071
9072 if (check_for_secret) {
9073 if (!dprov_template_attr_present(
9074 template, nattr,
9075 DPROV_CKA_PRIVATE_EXPONENT))
9076 return (
9077 CRYPTO_TEMPLATE_INCOMPLETE);
9078 }
9079 }
9080 }
9081 }
9082
9083 /* check for secret key attributes that must be present */
9084 if (class == DPROV_CKO_SECRET_KEY) {
9085 if (check_for_secret) {
9086 if (!dprov_template_attr_present(template, nattr,
9087 DPROV_CKA_VALUE)) {
9088 return (CRYPTO_TEMPLATE_INCOMPLETE);
9089 }
9090 }
9091
9092 /* these attributes should not be present */
9093 if (dprov_template_attr_present(template, nattr,
9094 DPROV_CKA_VALUE_LEN)) {
9095 return (CRYPTO_TEMPLATE_INCONSISTENT);
9096 }
9097 }
9098
9099 return (CRYPTO_SUCCESS);
9100 }
9101
9102 /*
9103 * Create an object from the specified template. Checks whether the
9104 * object can be created according to its attributes and the state
9105 * of the session. The new session object id is returned. If the
9106 * object is a token object, it is added to the per-instance object
9107 * table as well.
9108 */
9109 static int
9110 dprov_create_object_from_template(dprov_state_t *softc,
9111 dprov_session_t *session, crypto_object_attribute_t *template,
9112 uint_t nattr, crypto_object_id_t *object_id, boolean_t check_for_secret,
9113 boolean_t force)
9114 {
9115 dprov_object_t *object;
9116 boolean_t is_token = B_FALSE;
9117 boolean_t extractable_attribute_present = B_FALSE;
9118 boolean_t sensitive_attribute_present = B_FALSE;
9119 boolean_t private_attribute_present = B_FALSE;
9120 boolean_t token_attribute_present = B_FALSE;
9121 uint_t i;
9122 int error;
9123 uint_t attr;
9124 uint_t oattr;
9125 crypto_attr_type_t type;
9126 size_t old_len, new_len;
9127 offset_t offset;
9128
9129 if (nattr > DPROV_MAX_ATTR)
9130 return (CRYPTO_HOST_MEMORY);
9131
9132 if (!force) {
9133 /* verify that object can be created */
9134 if ((error = dprov_template_can_create(session, template,
9135 nattr, check_for_secret)) != CRYPTO_SUCCESS)
9136 return (error);
9137 }
9138
9139 /* allocate new object */
9140 object = kmem_zalloc(sizeof (dprov_object_t), KM_SLEEP);
9141 if (object == NULL)
9142 return (CRYPTO_HOST_MEMORY);
9143
9144 /* is it a token object? */
9145 /* check CKA_TOKEN attribute value */
9146 error = dprov_get_template_attr_boolean(template, nattr,
9147 DPROV_CKA_TOKEN, &is_token);
9148 if (error == CRYPTO_SUCCESS && is_token) {
9149 /* token object, add it to the per-instance object table */
9150 for (i = 0; i < DPROV_MAX_OBJECTS; i++)
9151 if (softc->ds_objects[i] == NULL)
9152 break;
9153 if (i == DPROV_MAX_OBJECTS)
9154 /* no free slot */
9155 return (CRYPTO_HOST_MEMORY);
9156 softc->ds_objects[i] = object;
9157 object->do_token_idx = i;
9158 DPROV_OBJECT_REFHOLD(object);
9159 }
9160
9161 /* add object to session object table */
9162 for (i = 0; i < DPROV_MAX_OBJECTS; i++)
9163 if (session->ds_objects[i] == NULL)
9164 break;
9165 if (i == DPROV_MAX_OBJECTS) {
9166 /* no more session object slots */
9167 DPROV_OBJECT_REFRELE(object);
9168 return (CRYPTO_HOST_MEMORY);
9169 }
9170 session->ds_objects[i] = object;
9171 DPROV_OBJECT_REFHOLD(object);
9172 *object_id = i;
9173
9174 /* initialize object from template */
9175 for (attr = 0, oattr = 0; attr < nattr; attr++) {
9176 if (template[attr].oa_value == NULL)
9177 continue;
9178 type = template[attr].oa_type;
9179 old_len = template[attr].oa_value_len;
9180 new_len = attribute_size(type, old_len);
9181
9182 if (type == DPROV_CKA_EXTRACTABLE) {
9183 extractable_attribute_present = B_TRUE;
9184 } else if (type == DPROV_CKA_PRIVATE) {
9185 private_attribute_present = B_TRUE;
9186 } else if (type == DPROV_CKA_TOKEN) {
9187 token_attribute_present = B_TRUE;
9188 }
9189 object->do_attr[oattr].oa_type = type;
9190 object->do_attr[oattr].oa_value_len = new_len;
9191
9192 object->do_attr[oattr].oa_value = kmem_zalloc(new_len,
9193 KM_SLEEP);
9194
9195 offset = 0;
9196 #ifdef _BIG_ENDIAN
9197 if (fixed_size_attribute(type)) {
9198 offset = old_len - new_len;
9199 }
9200 #endif
9201 bcopy(&template[attr].oa_value[offset],
9202 object->do_attr[oattr].oa_value, new_len);
9203 oattr++;
9204 }
9205
9206 /* add boolean attributes that must be present */
9207 if (extractable_attribute_present == B_FALSE) {
9208 object->do_attr[oattr].oa_type = DPROV_CKA_EXTRACTABLE;
9209 object->do_attr[oattr].oa_value_len = 1;
9210 object->do_attr[oattr].oa_value = kmem_alloc(1, KM_SLEEP);
9211 object->do_attr[oattr].oa_value[0] = B_TRUE;
9212 oattr++;
9213 }
9214
9215 if (private_attribute_present == B_FALSE) {
9216 object->do_attr[oattr].oa_type = DPROV_CKA_PRIVATE;
9217 object->do_attr[oattr].oa_value_len = 1;
9218 object->do_attr[oattr].oa_value = kmem_alloc(1, KM_SLEEP);
9219 object->do_attr[oattr].oa_value[0] = B_FALSE;
9220 oattr++;
9221 }
9222
9223 if (token_attribute_present == B_FALSE) {
9224 object->do_attr[oattr].oa_type = DPROV_CKA_TOKEN;
9225 object->do_attr[oattr].oa_value_len = 1;
9226 object->do_attr[oattr].oa_value = kmem_alloc(1, KM_SLEEP);
9227 object->do_attr[oattr].oa_value[0] = B_FALSE;
9228 oattr++;
9229 }
9230
9231 if (sensitive_attribute_present == B_FALSE) {
9232 object->do_attr[oattr].oa_type = DPROV_CKA_SENSITIVE;
9233 object->do_attr[oattr].oa_value_len = 1;
9234 object->do_attr[oattr].oa_value = kmem_alloc(1, KM_SLEEP);
9235 object->do_attr[oattr].oa_value[0] = B_FALSE;
9236 oattr++;
9237 }
9238 return (CRYPTO_SUCCESS);
9239 }
9240
9241 /*
9242 * Checks whether or not the object matches the specified attributes.
9243 *
9244 * PKCS#11 attributes which are longs are stored in uint32_t containers
9245 * so they can be matched by both 32 and 64-bit applications.
9246 */
9247 static boolean_t
9248 dprov_attributes_match(dprov_object_t *object,
9249 crypto_object_attribute_t *template, uint_t nattr)
9250 {
9251 crypto_attr_type_t type;
9252 size_t tlen, olen, diff;
9253 int ta_idx; /* template attribute index */
9254 int oa_idx; /* object attribute index */
9255
9256 for (ta_idx = 0; ta_idx < nattr; ta_idx++) {
9257 /* no value for template attribute */
9258 if (template[ta_idx].oa_value == NULL)
9259 continue;
9260
9261 /* find attribute in object */
9262 type = template[ta_idx].oa_type;
9263 oa_idx = dprov_find_attr(object->do_attr, DPROV_MAX_ATTR, type);
9264
9265 if (oa_idx == -1)
9266 /* attribute not found in object */
9267 return (B_FALSE);
9268
9269 tlen = template[ta_idx].oa_value_len;
9270 olen = object->do_attr[oa_idx].oa_value_len;
9271 if (tlen < olen)
9272 return (B_FALSE);
9273
9274 diff = 0;
9275 #ifdef _BIG_ENDIAN
9276 /* application may think attribute is 8 bytes */
9277 if (fixed_size_attribute(type))
9278 diff = tlen - olen;
9279 #endif
9280
9281 if (bcmp(&template[ta_idx].oa_value[diff],
9282 object->do_attr[oa_idx].oa_value, olen) != 0)
9283 /* value mismatch */
9284 return (B_FALSE);
9285 }
9286
9287 return (B_TRUE);
9288 }
9289
9290 /*
9291 * Destroy the object specified by its session and object id.
9292 */
9293 static int
9294 dprov_destroy_object(dprov_state_t *softc, dprov_session_t *session,
9295 crypto_object_id_t object_id)
9296 {
9297 dprov_object_t *object;
9298
9299 if ((object = session->ds_objects[object_id]) == NULL)
9300 return (CRYPTO_OBJECT_HANDLE_INVALID);
9301
9302 /* remove from session table */
9303 session->ds_objects[object_id] = NULL;
9304
9305 if (dprov_object_is_token(object)) {
9306 if (!object->do_destroyed) {
9307 object->do_destroyed = B_TRUE;
9308 /* remove from per-instance token table */
9309 softc->ds_objects[object->do_token_idx] = NULL;
9310 DPROV_OBJECT_REFRELE(object);
9311 } else {
9312 DPROV_DEBUG(D_OBJECT, ("dprov_destroy_object: "
9313 "object %p already destroyed\n", (void *)object));
9314 }
9315 }
9316
9317 DPROV_OBJECT_REFRELE(object);
9318 return (CRYPTO_SUCCESS);
9319 }
9320
9321 static int
9322 dprov_object_can_modify(dprov_object_t *object,
9323 crypto_object_attribute_t *template, uint_t nattr)
9324 {
9325 ulong_t object_class;
9326
9327 /* all objects should have an object class attribute */
9328 if (dprov_get_object_attr_ulong(object, DPROV_CKA_CLASS,
9329 &object_class) != CRYPTO_SUCCESS) {
9330 return (CRYPTO_SUCCESS);
9331 }
9332
9333 if (object_class == DPROV_CKO_SECRET_KEY ||
9334 object_class == DPROV_CKO_PUBLIC_KEY ||
9335 object_class == DPROV_CKO_PRIVATE_KEY) {
9336 if (dprov_template_attr_present(template, nattr,
9337 DPROV_CKA_CLASS) ||
9338 dprov_template_attr_present(template, nattr,
9339 DPROV_CKA_KEY_TYPE))
9340 return (CRYPTO_TEMPLATE_INCONSISTENT);
9341 }
9342
9343 switch (object_class) {
9344 case DPROV_CKO_SECRET_KEY:
9345 if (dprov_template_attr_present(template, nattr,
9346 DPROV_CKA_VALUE))
9347 return (CRYPTO_TEMPLATE_INCONSISTENT);
9348 break;
9349
9350 case DPROV_CKO_PUBLIC_KEY:
9351 if (dprov_template_attr_present(template, nattr,
9352 DPROV_CKA_MODULUS) ||
9353 dprov_template_attr_present(template, nattr,
9354 DPROV_CKA_PUBLIC_EXPONENT))
9355 return (CRYPTO_TEMPLATE_INCONSISTENT);
9356 break;
9357
9358 case DPROV_CKO_PRIVATE_KEY:
9359 if (dprov_template_attr_present(template, nattr,
9360 DPROV_CKA_MODULUS) ||
9361 dprov_template_attr_present(template, nattr,
9362 DPROV_CKA_PRIVATE_EXPONENT))
9363 return (CRYPTO_TEMPLATE_INCONSISTENT);
9364 break;
9365
9366 default:
9367 return (CRYPTO_SUCCESS);
9368 }
9369
9370 return (CRYPTO_SUCCESS);
9371 }
9372
9373 /*
9374 * Set the attributes specified by the template in the specified object,
9375 * replacing existing ones if needed.
9376 */
9377 static int
9378 dprov_object_set_attr(dprov_session_t *session, crypto_object_id_t object_id,
9379 crypto_object_attribute_t *template, uint_t nattr,
9380 boolean_t check_attributes)
9381 {
9382 crypto_attr_type_t type;
9383 dprov_object_t *object;
9384 size_t old_len, new_len;
9385 uint_t i, j;
9386 int error;
9387
9388 if ((object = session->ds_objects[object_id]) == NULL)
9389 return (CRYPTO_OBJECT_HANDLE_INVALID);
9390
9391 if (check_attributes) {
9392 /* verify that attributes in the template can be modified */
9393 if ((error = dprov_object_can_modify(object, template, nattr))
9394 != CRYPTO_SUCCESS)
9395 return (error);
9396 }
9397
9398 /* go through the attributes specified in the template */
9399 for (i = 0; i < nattr; i++) {
9400 if (template[i].oa_value == NULL)
9401 continue;
9402
9403 /* find attribute in object */
9404 type = template[i].oa_type;
9405 j = dprov_find_attr(object->do_attr, DPROV_MAX_ATTR, type);
9406
9407 if (j != -1) {
9408 /* attribute already exists, free old value */
9409 kmem_free(object->do_attr[j].oa_value,
9410 object->do_attr[j].oa_value_len);
9411 } else {
9412 /* attribute does not exist, create it */
9413 for (j = 0; j < DPROV_MAX_ATTR; j++)
9414 if (object->do_attr[j].oa_value == NULL)
9415 break;
9416 if (j == DPROV_MAX_ATTR)
9417 /* ran out of attribute slots */
9418 return (CRYPTO_HOST_MEMORY);
9419 }
9420
9421 old_len = template[i].oa_value_len;
9422 new_len = attribute_size(type, old_len);
9423
9424 /* set object attribute value */
9425 object->do_attr[j].oa_value = kmem_alloc(new_len, KM_SLEEP);
9426 bcopy(&template[i].oa_value[old_len - new_len],
9427 object->do_attr[j].oa_value, new_len);
9428 object->do_attr[j].oa_value_len = new_len;
9429
9430 /* and the type */
9431 object->do_attr[j].oa_type = type;
9432 }
9433
9434 return (CRYPTO_SUCCESS);
9435 }
9436
9437
9438 /*
9439 * Free the specified object.
9440 */
9441 static void
9442 dprov_free_object(dprov_object_t *object)
9443 {
9444 int i;
9445
9446 /* free the object attributes values */
9447 for (i = 0; i < DPROV_MAX_ATTR; i++)
9448 if (object->do_attr[i].oa_value != NULL)
9449 kmem_free(object->do_attr[i].oa_value,
9450 object->do_attr[i].oa_value_len);
9451
9452 /* free the object */
9453 kmem_free(object, sizeof (dprov_object_t));
9454 }
9455
9456 /*
9457 * Checks whether the specified object is a private or public object.
9458 */
9459 static boolean_t
9460 dprov_object_is_private(dprov_object_t *object)
9461 {
9462 boolean_t ret;
9463 int err;
9464
9465 err = dprov_get_object_attr_boolean(object, DPROV_CKA_PRIVATE, &ret);
9466
9467 if (err != CRYPTO_SUCCESS)
9468 /* by default, CKA_PRIVATE is false */
9469 ret = B_FALSE;
9470
9471 return (ret);
9472 }
9473
9474 /*
9475 * Checks whether the specified object is a token or session object.
9476 */
9477 static boolean_t
9478 dprov_object_is_token(dprov_object_t *object)
9479 {
9480 boolean_t ret;
9481 int err;
9482
9483 err = dprov_get_object_attr_boolean(object, DPROV_CKA_TOKEN, &ret);
9484
9485 if (err != CRYPTO_SUCCESS)
9486 /* by default, CKA_TOKEN is false */
9487 ret = B_FALSE;
9488
9489 return (ret);
9490 }
9491
9492 /*
9493 * Common function used by the dprov_get_object_attr_*() family of
9494 * functions. Returns the value of the specified attribute of specified
9495 * length. Returns CRYPTO_SUCCESS on success, CRYPTO_ATTRIBUTE_VALUE_INVALID
9496 * if the length of the attribute does not match the specified length,
9497 * or CRYPTO_ARGUMENTS_BAD if the attribute cannot be found.
9498 */
9499 static int
9500 dprov_get_object_attr_scalar_common(dprov_object_t *object, uint64_t attr_type,
9501 void *value, size_t value_len)
9502 {
9503 int attr_idx;
9504 size_t oa_value_len;
9505 size_t offset = 0;
9506
9507 if ((attr_idx = dprov_find_attr(object->do_attr, DPROV_MAX_ATTR,
9508 attr_type)) == -1)
9509 return (CRYPTO_ARGUMENTS_BAD);
9510
9511 oa_value_len = object->do_attr[attr_idx].oa_value_len;
9512 if (oa_value_len != value_len) {
9513 /*
9514 * For some attributes, it's okay to copy the value
9515 * into a larger container, e.g. copy an unsigned
9516 * 32-bit integer into a 64-bit container.
9517 */
9518 if (attr_type == DPROV_CKA_VALUE_LEN ||
9519 attr_type == DPROV_CKA_KEY_TYPE ||
9520 attr_type == DPROV_CKA_CLASS) {
9521 if (oa_value_len < value_len) {
9522 #ifdef _BIG_ENDIAN
9523 offset = value_len - oa_value_len;
9524 #endif
9525 bzero(value, value_len);
9526 goto do_copy;
9527 }
9528 }
9529 /* incorrect attribute value length */
9530 return (CRYPTO_ATTRIBUTE_VALUE_INVALID);
9531 }
9532
9533 do_copy:
9534 bcopy(object->do_attr[attr_idx].oa_value, (uchar_t *)value + offset,
9535 oa_value_len);
9536
9537 return (CRYPTO_SUCCESS);
9538 }
9539
9540 /*
9541 * Get the value of the a boolean attribute from the specified object.
9542 */
9543 static int
9544 dprov_get_object_attr_boolean(dprov_object_t *object, uint64_t attr_type,
9545 boolean_t *attr_value)
9546 {
9547 uchar_t val;
9548 int ret;
9549
9550 /* PKCS#11 defines a boolean as one byte */
9551 ret = dprov_get_object_attr_scalar_common(object, attr_type, &val, 1);
9552 if (ret == CRYPTO_SUCCESS) {
9553 *attr_value = (val == '\0') ? B_FALSE : B_TRUE;
9554 }
9555 return (ret);
9556 }
9557
9558 /*
9559 * Get the value of a ulong_t attribute from the specified object.
9560 */
9561 static int
9562 dprov_get_object_attr_ulong(dprov_object_t *object, uint64_t attr_type,
9563 ulong_t *attr_value)
9564 {
9565 return (dprov_get_object_attr_scalar_common(object, attr_type,
9566 attr_value, sizeof (ulong_t)));
9567 }
9568
9569 /*
9570 * Find the specified byte array attribute of specified type in
9571 * the specified object. Returns CRYPTO_SUCCESS
9572 * on success or CRYPTO_ARGUMENTS_BAD if the specified
9573 * attribute cannot be found.
9574 */
9575 static int
9576 dprov_get_object_attr_array(dprov_object_t *object, uint64_t attr_type,
9577 void **array, size_t *len)
9578 {
9579 int attr_idx;
9580
9581 if ((attr_idx = dprov_find_attr(object->do_attr, DPROV_MAX_ATTR,
9582 attr_type)) == -1)
9583 return (CRYPTO_ARGUMENTS_BAD);
9584
9585 *array = object->do_attr[attr_idx].oa_value;
9586 *len = object->do_attr[attr_idx].oa_value_len;
9587
9588 return (CRYPTO_SUCCESS);
9589 }
9590
9591 /*
9592 * Common function used by the dprov_get_template_attr_*() family of
9593 * functions. Returns the value of the specified attribute of specified
9594 * length. Returns CRYPTO_SUCCESS on success, CRYPTO_ATTRIBUTE_VALUE_INVALID
9595 * if the length of the attribute does not match the specified length,
9596 * or CRYPTO_ARGUMENTS_BAD if the attribute cannot be found.
9597 */
9598 static int
9599 dprov_get_template_attr_scalar_common(crypto_object_attribute_t *template,
9600 uint_t nattr, uint64_t attr_type, void *value, size_t value_len)
9601 {
9602 size_t oa_value_len;
9603 size_t offset = 0;
9604 int attr_idx;
9605
9606 if ((attr_idx = dprov_find_attr(template, nattr, attr_type)) == -1)
9607 return (CRYPTO_ARGUMENTS_BAD);
9608
9609 oa_value_len = template[attr_idx].oa_value_len;
9610 if (oa_value_len != value_len) {
9611 /*
9612 * For some attributes, it's okay to copy the value
9613 * into a larger container, e.g. copy an unsigned
9614 * 32-bit integer into a 64-bit container.
9615 */
9616 if (attr_type == DPROV_CKA_VALUE_LEN ||
9617 attr_type == DPROV_CKA_KEY_TYPE ||
9618 attr_type == DPROV_CKA_CLASS) {
9619 if (oa_value_len < value_len) {
9620 #ifdef _BIG_ENDIAN
9621 offset = value_len - oa_value_len;
9622 #endif
9623 bzero(value, value_len);
9624 goto do_copy;
9625 }
9626 }
9627 /* incorrect attribute value length */
9628 return (CRYPTO_ATTRIBUTE_VALUE_INVALID);
9629 }
9630
9631 do_copy:
9632 bcopy(template[attr_idx].oa_value, (uchar_t *)value + offset,
9633 oa_value_len);
9634
9635 return (CRYPTO_SUCCESS);
9636 }
9637
9638 /*
9639 * Get the value of the a boolean attribute from the specified template
9640 */
9641 static int
9642 dprov_get_template_attr_boolean(crypto_object_attribute_t *template,
9643 uint_t nattr, uint64_t attr_type, boolean_t *attr_value)
9644 {
9645 uchar_t val;
9646 int ret;
9647
9648 /* PKCS#11 defines a boolean as one byte */
9649 ret = dprov_get_template_attr_scalar_common(template, nattr,
9650 attr_type, &val, 1);
9651 if (ret == CRYPTO_SUCCESS) {
9652 *attr_value = (val == '\0') ? B_FALSE : B_TRUE;
9653 }
9654 return (ret);
9655 }
9656
9657 /*
9658 * Get the value of a ulong_t attribute from the specified template.
9659 */
9660 static int
9661 dprov_get_template_attr_ulong(crypto_object_attribute_t *template,
9662 uint_t nattr, uint64_t attr_type, ulong_t *attr_value)
9663 {
9664 return (dprov_get_template_attr_scalar_common(template, nattr,
9665 attr_type, attr_value, sizeof (ulong_t)));
9666 }
9667
9668 static int
9669 dprov_template_attr_present(crypto_object_attribute_t *template,
9670 uint_t nattr, uint64_t attr_type)
9671 {
9672 return (dprov_find_attr(template, nattr,
9673 attr_type) == -1 ? B_FALSE : B_TRUE);
9674 }
9675
9676 /*
9677 * Find the specified byte array attribute of specified type in
9678 * the specified template. Returns CRYPTO_SUCCESS on success or
9679 * CRYPTO_ARGUMENTS_BAD if the specified attribute cannot be found.
9680 */
9681 static int
9682 dprov_get_template_attr_array(crypto_object_attribute_t *template,
9683 uint_t nattr, uint64_t attr_type, void **array, size_t *len)
9684 {
9685 int attr_idx;
9686
9687 if ((attr_idx = dprov_find_attr(template, nattr, attr_type)) == -1)
9688 return (CRYPTO_ARGUMENTS_BAD);
9689
9690 *array = template[attr_idx].oa_value;
9691 *len = template[attr_idx].oa_value_len;
9692
9693 return (CRYPTO_SUCCESS);
9694 }
9695
9696 /*
9697 * Common function used by the dprov_get_key_attr_*() family of
9698 * functions. Returns the value of the specified attribute of specified
9699 * length. Returns CRYPTO_SUCCESS on success, CRYPTO_ATTRIBUTE_VALUE_INVALID
9700 * if the length of the attribute does not match the specified length,
9701 * or CRYPTO_ARGUMENTS_BAD if the attribute cannot be found.
9702 */
9703 static int
9704 dprov_get_key_attr_scalar_common(crypto_key_t *key, uint64_t attr_type,
9705 void *value, size_t value_len)
9706 {
9707 int attr_idx;
9708
9709 ASSERT(key->ck_format == CRYPTO_KEY_ATTR_LIST);
9710
9711 if ((attr_idx = dprov_find_attr(key->ck_attrs, key->ck_count,
9712 attr_type)) == -1)
9713 return (CRYPTO_ARGUMENTS_BAD);
9714
9715 if (key->ck_attrs[attr_idx].oa_value_len != value_len)
9716 /* incorrect attribute value length */
9717 return (CRYPTO_ATTRIBUTE_VALUE_INVALID);
9718
9719 bcopy(key->ck_attrs[attr_idx].oa_value, value, value_len);
9720
9721 return (CRYPTO_SUCCESS);
9722 }
9723
9724 /*
9725 * Get the value of a ulong_t attribute from the specified key.
9726 */
9727 static int
9728 dprov_get_key_attr_ulong(crypto_key_t *key, uint64_t attr_type,
9729 ulong_t *attr_value)
9730 {
9731 return (dprov_get_key_attr_scalar_common(key, attr_type,
9732 attr_value, sizeof (ulong_t)));
9733 }
9734
9735 /*
9736 * Find the specified byte array attribute of specified type in
9737 * the specified key by attributes. Returns CRYPTO_SUCCESS
9738 * on success or CRYPTO_ARGUMENTS_BAD if the specified
9739 * attribute cannot be found.
9740 */
9741 static int
9742 dprov_get_key_attr_array(crypto_key_t *key, uint64_t attr_type,
9743 void **array, size_t *len)
9744 {
9745 int attr_idx;
9746
9747 ASSERT(key->ck_format == CRYPTO_KEY_ATTR_LIST);
9748
9749 if ((attr_idx = dprov_find_attr(key->ck_attrs, key->ck_count,
9750 attr_type)) == -1)
9751 return (CRYPTO_ARGUMENTS_BAD);
9752
9753 *array = key->ck_attrs[attr_idx].oa_value;
9754 *len = key->ck_attrs[attr_idx].oa_value_len;
9755
9756 return (CRYPTO_SUCCESS);
9757 }
9758
9759 static void
9760 dprov_release_session_objects(dprov_session_t *session)
9761 {
9762 dprov_object_t *object;
9763 int i;
9764
9765 for (i = 0; i < DPROV_MAX_OBJECTS; i++) {
9766 object = session->ds_objects[i];
9767 if (object != NULL) {
9768 DPROV_OBJECT_REFRELE(object);
9769 }
9770 }
9771 }
9772
9773 /*
9774 * Adjust an attribute list by turning 32-bit values into 64-bit values
9775 * for certain attributes like CKA_CLASS. Assumes that at least 8 bytes
9776 * of storage have been allocated for all attributes.
9777 */
9778 static void
9779 dprov_adjust_attrs(crypto_object_attribute_t *in, int in_count)
9780 {
9781 int i;
9782 size_t offset = 0;
9783 ulong_t tmp = 0;
9784
9785 for (i = 0; i < in_count; i++) {
9786 /*
9787 * For some attributes, it's okay to copy the value
9788 * into a larger container, e.g. copy an unsigned
9789 * 32-bit integer into a 64-bit container.
9790 */
9791 if (in[i].oa_type == CKA_VALUE_LEN ||
9792 in[i].oa_type == CKA_KEY_TYPE ||
9793 in[i].oa_type == CKA_CLASS) {
9794 if (in[i].oa_value_len < sizeof (ulong_t)) {
9795 #ifdef _BIG_ENDIAN
9796 offset = sizeof (ulong_t) - in[i].oa_value_len;
9797 #endif
9798 bcopy(in[i].oa_value, (uchar_t *)&tmp + offset,
9799 in[i].oa_value_len);
9800 bcopy(&tmp, in[i].oa_value, sizeof (ulong_t));
9801 in[i].oa_value_len = sizeof (ulong_t);
9802 }
9803 }
9804 }
9805 }