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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <security/cryptoki.h>
28 #include "pkcs11Global.h"
29 #include "pkcs11Session.h"
30 #include "pkcs11Slot.h"
31
32 /*
33 * C_CreateObject is a pure wrapper to the underlying provider.
34 * The only argument checked is whether or not hSession is valid.
35 */
36 CK_RV
C_CreateObject(CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phObject)37 C_CreateObject(CK_SESSION_HANDLE hSession,
38 CK_ATTRIBUTE_PTR pTemplate,
39 CK_ULONG ulCount,
40 CK_OBJECT_HANDLE_PTR phObject)
41 {
42
43 CK_RV rv;
44 pkcs11_session_t *sessp;
45
46 /* Check for a fastpath */
47 if (purefastpath || policyfastpath) {
48 return (fast_funcs->C_CreateObject(hSession, pTemplate,
49 ulCount, phObject));
50 }
51
52 if (!pkcs11_initialized) {
53 return (CKR_CRYPTOKI_NOT_INITIALIZED);
54 }
55
56 /* Obtain the session pointer */
57 HANDLE2SESSION(hSession, sessp, rv);
58
59 if (rv != CKR_OK) {
60 return (rv);
61 }
62
63 /* Pass data to the provider */
64 rv = FUNCLIST(sessp->se_slotid)->C_CreateObject(sessp->se_handle,
65 pTemplate, ulCount, phObject);
66
67 /* Present consistent interface to the application */
68 if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
69 return (CKR_FUNCTION_FAILED);
70 }
71
72 return (rv);
73 }
74
75 /*
76 * C_CopyObject is a pure wrapper to the underlying provider.
77 * The only argument checked is whether or not hSession is valid.
78 */
79 CK_RV
C_CopyObject(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phNewObject)80 C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
81 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
82 CK_OBJECT_HANDLE_PTR phNewObject)
83 {
84 CK_RV rv;
85 pkcs11_session_t *sessp;
86
87 /* Check for a fastpath */
88 if (purefastpath || policyfastpath) {
89 return (fast_funcs->C_CopyObject(hSession, hObject,
90 pTemplate, ulCount, phNewObject));
91 }
92
93 if (!pkcs11_initialized) {
94 return (CKR_CRYPTOKI_NOT_INITIALIZED);
95 }
96
97 /* Obtain the session pointer */
98 HANDLE2SESSION(hSession, sessp, rv);
99
100 if (rv != CKR_OK) {
101 return (rv);
102 }
103
104 /* Pass data to the provider */
105 rv = FUNCLIST(sessp->se_slotid)->C_CopyObject(sessp->se_handle,
106 hObject, pTemplate, ulCount, phNewObject);
107
108 /* Present consistent interface to the application */
109 if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
110 return (CKR_FUNCTION_FAILED);
111 }
112
113 return (rv);
114 }
115
116 /*
117 * C_DestroyObject is a pure wrapper to the underlying provider.
118 * The only argument checked is whether or not hSession is valid.
119 */
120 CK_RV
C_DestroyObject(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject)121 C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject)
122 {
123 CK_RV rv;
124 pkcs11_session_t *sessp;
125
126 /* Check for a fastpath */
127 if (purefastpath || policyfastpath) {
128 return (fast_funcs->C_DestroyObject(hSession, hObject));
129 }
130
131 if (!pkcs11_initialized) {
132 return (CKR_CRYPTOKI_NOT_INITIALIZED);
133 }
134
135 /* Obtain the session pointer */
136 HANDLE2SESSION(hSession, sessp, rv);
137
138 if (rv != CKR_OK) {
139 return (rv);
140 }
141
142 /* Pass data to the provider */
143 rv = FUNCLIST(sessp->se_slotid)->C_DestroyObject(sessp->se_handle,
144 hObject);
145
146 /* Present consistent interface to the application */
147 if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
148 return (CKR_FUNCTION_FAILED);
149 }
150
151 return (rv);
152 }
153
154 /*
155 * C_GetAttributeValue is a pure wrapper to the underlying provider.
156 * The only argument checked is whether or not hSession is valid.
157 */
158 CK_RV
C_GetAttributeValue(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)159 C_GetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
160 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
161 {
162 CK_RV rv;
163 pkcs11_session_t *sessp;
164
165 /* Check for a fastpath */
166 if (purefastpath || policyfastpath) {
167 return (fast_funcs->C_GetAttributeValue(hSession, hObject,
168 pTemplate, ulCount));
169 }
170
171 if (!pkcs11_initialized) {
172 return (CKR_CRYPTOKI_NOT_INITIALIZED);
173 }
174
175 /* Obtain the session pointer */
176 HANDLE2SESSION(hSession, sessp, rv);
177
178 if (rv != CKR_OK) {
179 return (rv);
180 }
181
182 /* Pass data to the provider */
183 rv = FUNCLIST(sessp->se_slotid)->C_GetAttributeValue(sessp->se_handle,
184 hObject, pTemplate, ulCount);
185
186 /* Present consistent interface to the application */
187 if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
188 return (CKR_FUNCTION_FAILED);
189 }
190
191 return (rv);
192
193 }
194
195 /*
196 * C_SetAttributeValue is a pure wrapper to the underlying provider.
197 * The only argument checked is whether or not hSession is valid.
198 */
199 CK_RV
C_SetAttributeValue(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)200 C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
201 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
202 {
203 CK_RV rv;
204 pkcs11_session_t *sessp;
205
206 /* Check for a fastpath */
207 if (purefastpath || policyfastpath) {
208 return (fast_funcs->C_SetAttributeValue(hSession, hObject,
209 pTemplate, ulCount));
210 }
211
212 if (!pkcs11_initialized) {
213 return (CKR_CRYPTOKI_NOT_INITIALIZED);
214 }
215
216 /* Obtain the session pointer */
217 HANDLE2SESSION(hSession, sessp, rv);
218
219 if (rv != CKR_OK) {
220 return (rv);
221 }
222
223 /* Pass data to the provider */
224 rv = FUNCLIST(sessp->se_slotid)->C_SetAttributeValue(sessp->se_handle,
225 hObject, pTemplate, ulCount);
226
227 /* Present consistent interface to the application */
228 if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
229 return (CKR_FUNCTION_FAILED);
230 }
231
232 return (rv);
233 }
234
235 /*
236 * C_GetObjectSize is a pure wrapper to the underlying provider.
237 * The only argument checked is whether or not hSession is valid.
238 */
239 CK_RV
C_GetObjectSize(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ULONG_PTR pulSize)240 C_GetObjectSize(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
241 CK_ULONG_PTR pulSize)
242 {
243 CK_RV rv;
244 pkcs11_session_t *sessp;
245
246 /* Check for a fastpath */
247 if (purefastpath || policyfastpath) {
248 return (fast_funcs->C_GetObjectSize(hSession, hObject,
249 pulSize));
250 }
251
252 if (!pkcs11_initialized) {
253 return (CKR_CRYPTOKI_NOT_INITIALIZED);
254 }
255
256 /* Obtain the session pointer */
257 HANDLE2SESSION(hSession, sessp, rv);
258
259 if (rv != CKR_OK) {
260 return (rv);
261 }
262
263 /* Pass data to the provider */
264 rv = FUNCLIST(sessp->se_slotid)->C_GetObjectSize(sessp->se_handle,
265 hObject, pulSize);
266
267 /* Present consistent interface to the application */
268 if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
269 return (CKR_FUNCTION_FAILED);
270 }
271
272 return (rv);
273 }
274
275 /*
276 * C_FindObjectsInit is a pure wrapper to the underlying provider.
277 * The only argument checked is whether or not hSession is valid.
278 */
279 CK_RV
C_FindObjectsInit(CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)280 C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate,
281 CK_ULONG ulCount)
282 {
283 CK_RV rv;
284 pkcs11_session_t *sessp;
285
286 /* Check for a fastpath */
287 if (purefastpath || policyfastpath) {
288 return (fast_funcs->C_FindObjectsInit(hSession, pTemplate,
289 ulCount));
290 }
291
292 if (!pkcs11_initialized) {
293 return (CKR_CRYPTOKI_NOT_INITIALIZED);
294 }
295
296 /* Obtain the session pointer */
297 HANDLE2SESSION(hSession, sessp, rv);
298
299 if (rv != CKR_OK) {
300 return (rv);
301 }
302
303 /* Pass data to the provider */
304 rv = FUNCLIST(sessp->se_slotid)->C_FindObjectsInit(sessp->se_handle,
305 pTemplate, ulCount);
306
307 /* Present consistent interface to the application */
308 if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
309 return (CKR_FUNCTION_FAILED);
310 }
311
312 return (rv);
313 }
314
315 /*
316 * C_FindObjects is a pure wrapper to the underlying provider.
317 * The only argument checked is whether or not hSession is valid.
318 */
319 CK_RV
C_FindObjects(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE_PTR phObject,CK_ULONG ulMaxObjectCount,CK_ULONG_PTR pulObjectCount)320 C_FindObjects(CK_SESSION_HANDLE hSession,
321 CK_OBJECT_HANDLE_PTR phObject,
322 CK_ULONG ulMaxObjectCount,
323 CK_ULONG_PTR pulObjectCount)
324 {
325 CK_RV rv;
326 pkcs11_session_t *sessp;
327
328 /* Check for a fastpath */
329 if (purefastpath || policyfastpath) {
330 return (fast_funcs->C_FindObjects(hSession, phObject,
331 ulMaxObjectCount, pulObjectCount));
332 }
333
334 if (!pkcs11_initialized) {
335 return (CKR_CRYPTOKI_NOT_INITIALIZED);
336 }
337
338 /* Obtain the session pointer */
339 HANDLE2SESSION(hSession, sessp, rv);
340
341 if (rv != CKR_OK) {
342 return (rv);
343 }
344
345 /* Pass data to the provider */
346 rv = FUNCLIST(sessp->se_slotid)->C_FindObjects(sessp->se_handle,
347 phObject, ulMaxObjectCount, pulObjectCount);
348
349 /* Present consistent interface to the application */
350 if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
351 return (CKR_FUNCTION_FAILED);
352 }
353
354 return (rv);
355 }
356
357 /*
358 * C_FindObjectsFinal is a pure wrapper to the underlying provider.
359 * The only argument checked is whether or not hSession is valid.
360 */
361 CK_RV
C_FindObjectsFinal(CK_SESSION_HANDLE hSession)362 C_FindObjectsFinal(CK_SESSION_HANDLE hSession)
363 {
364 CK_RV rv;
365 pkcs11_session_t *sessp;
366
367 /* Check for a fastpath */
368 if (purefastpath || policyfastpath) {
369 return (fast_funcs->C_FindObjectsFinal(hSession));
370 }
371
372 if (!pkcs11_initialized) {
373 return (CKR_CRYPTOKI_NOT_INITIALIZED);
374 }
375
376 /* Obtain the session pointer */
377 HANDLE2SESSION(hSession, sessp, rv);
378
379 if (rv != CKR_OK) {
380 return (rv);
381 }
382
383 /* Pass data to the provider */
384 rv = FUNCLIST(sessp->se_slotid)->C_FindObjectsFinal(sessp->se_handle);
385
386 /* Present consistent interface to the application */
387 if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
388 return (CKR_FUNCTION_FAILED);
389 }
390
391 return (rv);
392 }
393