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 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 /*
29 * Encryption and Decryption Functions
30 * (as defined in PKCS#11 spec sections 11.8 and 11.9)
31 */
32
33 #include "metaGlobal.h"
34
35
36 /*
37 * meta_EncryptInit
38 *
39 */
40 CK_RV
meta_EncryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)41 meta_EncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
42 CK_OBJECT_HANDLE hKey)
43 {
44 CK_RV rv;
45 meta_session_t *session;
46 meta_object_t *key;
47
48 if (pMechanism == NULL)
49 return (CKR_ARGUMENTS_BAD);
50
51 rv = meta_handle2session(hSession, &session);
52 if (rv != CKR_OK)
53 return (rv);
54
55 rv = meta_handle2object(hKey, &key);
56 if (rv != CKR_OK) {
57 REFRELEASE(session);
58 return (rv);
59 }
60
61 rv = meta_operation_init_defer(CKF_ENCRYPT, session, pMechanism, key);
62
63 OBJRELEASE(key);
64 REFRELEASE(session);
65
66 return (rv);
67 }
68
69
70 /*
71 * meta_Encrypt
72 *
73 */
74 CK_RV
meta_Encrypt(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pEncryptedData,CK_ULONG_PTR pulEncryptedDataLen)75 meta_Encrypt(CK_SESSION_HANDLE hSession,
76 CK_BYTE_PTR pData, CK_ULONG ulDataLen,
77 CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen)
78 {
79 CK_RV rv;
80 meta_session_t *session;
81
82 rv = meta_handle2session(hSession, &session);
83 if (rv != CKR_OK)
84 return (rv);
85
86 if (pData == NULL || pulEncryptedDataLen == NULL) {
87 meta_operation_cleanup(session, CKF_ENCRYPT, FALSE);
88 REFRELEASE(session);
89 return (CKR_ARGUMENTS_BAD);
90 }
91
92 rv = meta_do_operation(CKF_ENCRYPT, MODE_SINGLE, session, NULL,
93 pData, ulDataLen, pEncryptedData, pulEncryptedDataLen);
94
95 REFRELEASE(session);
96
97 return (rv);
98 }
99
100
101 /*
102 * meta_EncryptUpdate
103 *
104 */
105 CK_RV
meta_EncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)106 meta_EncryptUpdate(CK_SESSION_HANDLE hSession,
107 CK_BYTE_PTR pPart, CK_ULONG ulPartLen,
108 CK_BYTE_PTR pEncryptedPart, CK_ULONG_PTR pulEncryptedPartLen)
109 {
110 CK_RV rv;
111 meta_session_t *session;
112
113 rv = meta_handle2session(hSession, &session);
114 if (rv != CKR_OK)
115 return (rv);
116
117 if (pPart == NULL || pulEncryptedPartLen == NULL) {
118 meta_operation_cleanup(session, CKF_ENCRYPT, FALSE);
119 REFRELEASE(session);
120 return (CKR_ARGUMENTS_BAD);
121 }
122
123 rv = meta_do_operation(CKF_ENCRYPT, MODE_UPDATE, session, NULL,
124 pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
125
126 REFRELEASE(session);
127
128 return (rv);
129 }
130
131
132 /*
133 * meta_EncryptFinal
134 *
135 */
136 CK_RV
meta_EncryptFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastEncryptedPart,CK_ULONG_PTR pulLastEncryptedPartLen)137 meta_EncryptFinal(CK_SESSION_HANDLE hSession,
138 CK_BYTE_PTR pLastEncryptedPart, CK_ULONG_PTR pulLastEncryptedPartLen)
139 {
140 CK_RV rv;
141 meta_session_t *session;
142
143 rv = meta_handle2session(hSession, &session);
144 if (rv != CKR_OK)
145 return (rv);
146
147 if (pulLastEncryptedPartLen == NULL) {
148 meta_operation_cleanup(session, CKF_ENCRYPT, FALSE);
149 REFRELEASE(session);
150 return (CKR_ARGUMENTS_BAD);
151 }
152
153 rv = meta_do_operation(CKF_ENCRYPT, MODE_FINAL, session, NULL,
154 NULL, 0, pLastEncryptedPart, pulLastEncryptedPartLen);
155
156 REFRELEASE(session);
157
158 return (rv);
159 }
160
161
162 /*
163 * meta_DecryptInit
164 *
165 */
166 CK_RV
meta_DecryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)167 meta_DecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
168 CK_OBJECT_HANDLE hKey)
169 {
170 CK_RV rv;
171 meta_session_t *session;
172 meta_object_t *key;
173
174 if (pMechanism == NULL)
175 return (CKR_ARGUMENTS_BAD);
176
177 rv = meta_handle2session(hSession, &session);
178 if (rv != CKR_OK)
179 return (rv);
180
181 rv = meta_handle2object(hKey, &key);
182 if (rv != CKR_OK) {
183 REFRELEASE(session);
184 return (rv);
185 }
186
187 rv = meta_operation_init_defer(CKF_DECRYPT, session, pMechanism, key);
188
189 OBJRELEASE(key);
190 REFRELEASE(session);
191
192 return (rv);
193 }
194
195
196 /*
197 * meta_Decrypt
198 *
199 */
200 CK_RV
meta_Decrypt(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedData,CK_ULONG ulEncryptedDataLen,CK_BYTE_PTR pData,CK_ULONG_PTR pulDataLen)201 meta_Decrypt(CK_SESSION_HANDLE hSession,
202 CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen,
203 CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen)
204 {
205 CK_RV rv;
206 meta_session_t *session;
207
208 rv = meta_handle2session(hSession, &session);
209 if (rv != CKR_OK)
210 return (rv);
211
212 if (pEncryptedData == NULL || pulDataLen == NULL) {
213 meta_operation_cleanup(session, CKF_DECRYPT, FALSE);
214 REFRELEASE(session);
215 return (CKR_ARGUMENTS_BAD);
216 }
217
218 rv = meta_do_operation(CKF_DECRYPT, MODE_SINGLE, session, NULL,
219 pEncryptedData, ulEncryptedDataLen, pData, pulDataLen);
220
221 REFRELEASE(session);
222
223 return (rv);
224 }
225
226
227 /*
228 * meta_DecryptUpdate
229 *
230 */
231 CK_RV
meta_DecryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)232 meta_DecryptUpdate(CK_SESSION_HANDLE hSession,
233 CK_BYTE_PTR pEncryptedPart, CK_ULONG ulEncryptedPartLen,
234 CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen)
235 {
236 CK_RV rv;
237 meta_session_t *session;
238
239 rv = meta_handle2session(hSession, &session);
240 if (rv != CKR_OK)
241 return (rv);
242
243 if (pEncryptedPart == NULL || pulPartLen == NULL) {
244 meta_operation_cleanup(session, CKF_DECRYPT, FALSE);
245 REFRELEASE(session);
246 return (CKR_ARGUMENTS_BAD);
247 }
248
249 rv = meta_do_operation(CKF_DECRYPT, MODE_UPDATE, session, NULL,
250 pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
251
252 REFRELEASE(session);
253
254 return (rv);
255 }
256
257
258 /*
259 * meta_DecryptFinal
260 *
261 */
262 CK_RV
meta_DecryptFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastPart,CK_ULONG_PTR pulLastPartLen)263 meta_DecryptFinal(CK_SESSION_HANDLE hSession,
264 CK_BYTE_PTR pLastPart, CK_ULONG_PTR pulLastPartLen)
265 {
266 CK_RV rv;
267 meta_session_t *session;
268
269 rv = meta_handle2session(hSession, &session);
270 if (rv != CKR_OK)
271 return (rv);
272
273 if (pulLastPartLen == NULL) {
274 meta_operation_cleanup(session, CKF_DECRYPT, FALSE);
275 REFRELEASE(session);
276 return (CKR_ARGUMENTS_BAD);
277 }
278
279 rv = meta_do_operation(CKF_DECRYPT, MODE_FINAL, session, NULL,
280 NULL, 0, pLastPart, pulLastPartLen);
281
282 REFRELEASE(session);
283
284 return (rv);
285 }
286