Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(26)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: nss/lib/ckfw/mechanism.c

Issue 1843333003: Update NSPR to 4.12 and NSS to 3.23 on iOS (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/nss.git@master
Patch Set: Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « nss/lib/ckfw/instance.c ('k') | nss/lib/ckfw/mutex.c » ('j') | nss/lib/util/secoid.c » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* This Source Code Form is subject to the terms of the Mozilla Public 1 /* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this 2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4 4
5 /* 5 /*
6 * mechanism.c 6 * mechanism.c
7 * 7 *
8 * This file implements the NSSCKFWMechanism type and methods. 8 * This file implements the NSSCKFWMechanism type and methods.
9 */ 9 */
10 10
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
48 * nssCKFWMechanism_SignRecoverInit 48 * nssCKFWMechanism_SignRecoverInit
49 * nssCKFWMechanism_VerifyRecoverInit 49 * nssCKFWMechanism_VerifyRecoverInit
50 * nssCKFWMechanism_GenerateKey 50 * nssCKFWMechanism_GenerateKey
51 * nssCKFWMechanism_GenerateKeyPair 51 * nssCKFWMechanism_GenerateKeyPair
52 * nssCKFWMechanism_GetWrapKeyLength 52 * nssCKFWMechanism_GetWrapKeyLength
53 * nssCKFWMechanism_WrapKey 53 * nssCKFWMechanism_WrapKey
54 * nssCKFWMechanism_UnwrapKey 54 * nssCKFWMechanism_UnwrapKey
55 * nssCKFWMechanism_DeriveKey 55 * nssCKFWMechanism_DeriveKey
56 */ 56 */
57 57
58
59 struct NSSCKFWMechanismStr { 58 struct NSSCKFWMechanismStr {
60 NSSCKMDMechanism *mdMechanism; 59 NSSCKMDMechanism *mdMechanism;
61 NSSCKMDToken *mdToken; 60 NSSCKMDToken *mdToken;
62 NSSCKFWToken *fwToken; 61 NSSCKFWToken *fwToken;
63 NSSCKMDInstance *mdInstance; 62 NSSCKMDInstance *mdInstance;
64 NSSCKFWInstance *fwInstance; 63 NSSCKFWInstance *fwInstance;
65 }; 64 };
66 65
67 /* 66 /*
68 * nssCKFWMechanism_Create 67 * nssCKFWMechanism_Create
69 * 68 *
70 */ 69 */
71 NSS_IMPLEMENT NSSCKFWMechanism * 70 NSS_IMPLEMENT NSSCKFWMechanism *
72 nssCKFWMechanism_Create 71 nssCKFWMechanism_Create(
73 ( 72 NSSCKMDMechanism *mdMechanism,
74 NSSCKMDMechanism *mdMechanism, 73 NSSCKMDToken *mdToken,
75 NSSCKMDToken *mdToken, 74 NSSCKFWToken *fwToken,
76 NSSCKFWToken *fwToken, 75 NSSCKMDInstance *mdInstance,
77 NSSCKMDInstance *mdInstance, 76 NSSCKFWInstance *fwInstance)
78 NSSCKFWInstance *fwInstance
79 )
80 { 77 {
81 NSSCKFWMechanism *fwMechanism; 78 NSSCKFWMechanism *fwMechanism;
82 79
83 80 fwMechanism = nss_ZNEW(NULL, NSSCKFWMechanism);
84 fwMechanism = nss_ZNEW(NULL, NSSCKFWMechanism); 81 if (!fwMechanism) {
85 if (!fwMechanism) { 82 return (NSSCKFWMechanism *)NULL;
86 return (NSSCKFWMechanism *)NULL; 83 }
87 } 84 fwMechanism->mdMechanism = mdMechanism;
88 fwMechanism->mdMechanism = mdMechanism; 85 fwMechanism->mdToken = mdToken;
89 fwMechanism->mdToken = mdToken; 86 fwMechanism->fwToken = fwToken;
90 fwMechanism->fwToken = fwToken; 87 fwMechanism->mdInstance = mdInstance;
91 fwMechanism->mdInstance = mdInstance; 88 fwMechanism->fwInstance = fwInstance;
92 fwMechanism->fwInstance = fwInstance; 89 return fwMechanism;
93 return fwMechanism;
94 } 90 }
95 91
96 /* 92 /*
97 * nssCKFWMechanism_Destroy 93 * nssCKFWMechanism_Destroy
98 * 94 *
99 */ 95 */
100 NSS_IMPLEMENT void 96 NSS_IMPLEMENT void
101 nssCKFWMechanism_Destroy 97 nssCKFWMechanism_Destroy(
102 ( 98 NSSCKFWMechanism *fwMechanism)
103 NSSCKFWMechanism *fwMechanism
104 )
105 { 99 {
106 /* destroy any fw resources held by nssCKFWMechanism (currently none) */ 100 /* destroy any fw resources held by nssCKFWMechanism (currently none) */
107 101
108 if (!fwMechanism->mdMechanism->Destroy) { 102 if (!fwMechanism->mdMechanism->Destroy) {
109 /* destroys it's parent as well */ 103 /* destroys it's parent as well */
110 fwMechanism->mdMechanism->Destroy( 104 fwMechanism->mdMechanism->Destroy(
111 fwMechanism->mdMechanism, 105 fwMechanism->mdMechanism,
112 fwMechanism, 106 fwMechanism,
113 fwMechanism->mdInstance, 107 fwMechanism->mdInstance,
114 fwMechanism->fwInstance); 108 fwMechanism->fwInstance);
115 } 109 }
116 /* if the Destroy function wasn't supplied, then the mechanism is 'static', 110 /* if the Destroy function wasn't supplied, then the mechanism is 'static',
117 * and there is nothing to destroy */ 111 * and there is nothing to destroy */
118 return; 112 return;
119 } 113 }
120 114
121 /* 115 /*
122 * nssCKFWMechanism_GetMDMechanism 116 * nssCKFWMechanism_GetMDMechanism
123 * 117 *
124 */ 118 */
125 NSS_IMPLEMENT NSSCKMDMechanism * 119 NSS_IMPLEMENT NSSCKMDMechanism *
126 nssCKFWMechanism_GetMDMechanism 120 nssCKFWMechanism_GetMDMechanism(
127 ( 121 NSSCKFWMechanism *fwMechanism)
128 NSSCKFWMechanism *fwMechanism
129 )
130 { 122 {
131 return fwMechanism->mdMechanism; 123 return fwMechanism->mdMechanism;
132 } 124 }
133 125
134 /* 126 /*
135 * nssCKFWMechanism_GetMinKeySize 127 * nssCKFWMechanism_GetMinKeySize
136 * 128 *
137 */ 129 */
138 NSS_IMPLEMENT CK_ULONG 130 NSS_IMPLEMENT CK_ULONG
139 nssCKFWMechanism_GetMinKeySize 131 nssCKFWMechanism_GetMinKeySize(
140 ( 132 NSSCKFWMechanism *fwMechanism,
141 NSSCKFWMechanism *fwMechanism, 133 CK_RV *pError)
142 CK_RV *pError
143 )
144 { 134 {
145 if (!fwMechanism->mdMechanism->GetMinKeySize) { 135 if (!fwMechanism->mdMechanism->GetMinKeySize) {
146 return 0; 136 return 0;
147 } 137 }
148 138
149 return fwMechanism->mdMechanism->GetMinKeySize(fwMechanism->mdMechanism, 139 return fwMechanism->mdMechanism->GetMinKeySize(fwMechanism->mdMechanism,
150 fwMechanism, fwMechanism->mdToken, fwMechanism->fwToken, 140 fwMechanism, fwMechanism->mdT oken, fwMechanism->fwToken,
151 fwMechanism->mdInstance, fwMechanism->fwInstance, pError); 141 fwMechanism->mdInstance, fwMe chanism->fwInstance, pError);
152 } 142 }
153 143
154 /* 144 /*
155 * nssCKFWMechanism_GetMaxKeySize 145 * nssCKFWMechanism_GetMaxKeySize
156 * 146 *
157 */ 147 */
158 NSS_IMPLEMENT CK_ULONG 148 NSS_IMPLEMENT CK_ULONG
159 nssCKFWMechanism_GetMaxKeySize 149 nssCKFWMechanism_GetMaxKeySize(
160 ( 150 NSSCKFWMechanism *fwMechanism,
161 NSSCKFWMechanism *fwMechanism, 151 CK_RV *pError)
162 CK_RV *pError
163 )
164 { 152 {
165 if (!fwMechanism->mdMechanism->GetMaxKeySize) { 153 if (!fwMechanism->mdMechanism->GetMaxKeySize) {
166 return 0; 154 return 0;
167 } 155 }
168 156
169 return fwMechanism->mdMechanism->GetMaxKeySize(fwMechanism->mdMechanism, 157 return fwMechanism->mdMechanism->GetMaxKeySize(fwMechanism->mdMechanism,
170 fwMechanism, fwMechanism->mdToken, fwMechanism->fwToken, 158 fwMechanism, fwMechanism->mdT oken, fwMechanism->fwToken,
171 fwMechanism->mdInstance, fwMechanism->fwInstance, pError); 159 fwMechanism->mdInstance, fwMe chanism->fwInstance, pError);
172 } 160 }
173 161
174 /* 162 /*
175 * nssCKFWMechanism_GetInHardware 163 * nssCKFWMechanism_GetInHardware
176 * 164 *
177 */ 165 */
178 NSS_IMPLEMENT CK_BBOOL 166 NSS_IMPLEMENT CK_BBOOL
179 nssCKFWMechanism_GetInHardware 167 nssCKFWMechanism_GetInHardware(
180 ( 168 NSSCKFWMechanism *fwMechanism,
181 NSSCKFWMechanism *fwMechanism, 169 CK_RV *pError)
182 CK_RV *pError
183 )
184 { 170 {
185 if (!fwMechanism->mdMechanism->GetInHardware) { 171 if (!fwMechanism->mdMechanism->GetInHardware) {
186 return CK_FALSE; 172 return CK_FALSE;
187 } 173 }
188 174
189 return fwMechanism->mdMechanism->GetInHardware(fwMechanism->mdMechanism, 175 return fwMechanism->mdMechanism->GetInHardware(fwMechanism->mdMechanism,
190 fwMechanism, fwMechanism->mdToken, fwMechanism->fwToken, 176 fwMechanism, fwMechanism->mdT oken, fwMechanism->fwToken,
191 fwMechanism->mdInstance, fwMechanism->fwInstance, pError); 177 fwMechanism->mdInstance, fwMe chanism->fwInstance, pError);
192 } 178 }
193 179
194
195 /* 180 /*
196 * the following are determined automatically by which of the cryptographic 181 * the following are determined automatically by which of the cryptographic
197 * functions are defined for this mechanism. 182 * functions are defined for this mechanism.
198 */ 183 */
199 /* 184 /*
200 * nssCKFWMechanism_GetCanEncrypt 185 * nssCKFWMechanism_GetCanEncrypt
201 * 186 *
202 */ 187 */
203 NSS_EXTERN CK_BBOOL 188 NSS_EXTERN CK_BBOOL
204 nssCKFWMechanism_GetCanEncrypt 189 nssCKFWMechanism_GetCanEncrypt(
205 ( 190 NSSCKFWMechanism *fwMechanism,
206 NSSCKFWMechanism *fwMechanism, 191 CK_RV *pError)
207 CK_RV *pError
208 )
209 { 192 {
210 if (!fwMechanism->mdMechanism->EncryptInit) { 193 if (!fwMechanism->mdMechanism->EncryptInit) {
211 return CK_FALSE; 194 return CK_FALSE;
212 } 195 }
213 return CK_TRUE; 196 return CK_TRUE;
214 } 197 }
215 198
216 /* 199 /*
217 * nssCKFWMechanism_GetCanDecrypt 200 * nssCKFWMechanism_GetCanDecrypt
218 * 201 *
219 */ 202 */
220 NSS_EXTERN CK_BBOOL 203 NSS_EXTERN CK_BBOOL
221 nssCKFWMechanism_GetCanDecrypt 204 nssCKFWMechanism_GetCanDecrypt(
222 ( 205 NSSCKFWMechanism *fwMechanism,
223 NSSCKFWMechanism *fwMechanism, 206 CK_RV *pError)
224 CK_RV *pError
225 )
226 { 207 {
227 if (!fwMechanism->mdMechanism->DecryptInit) { 208 if (!fwMechanism->mdMechanism->DecryptInit) {
228 return CK_FALSE; 209 return CK_FALSE;
229 } 210 }
230 return CK_TRUE; 211 return CK_TRUE;
231 } 212 }
232 213
233 /* 214 /*
234 * nssCKFWMechanism_GetCanDigest 215 * nssCKFWMechanism_GetCanDigest
235 * 216 *
236 */ 217 */
237 NSS_EXTERN CK_BBOOL 218 NSS_EXTERN CK_BBOOL
238 nssCKFWMechanism_GetCanDigest 219 nssCKFWMechanism_GetCanDigest(
239 ( 220 NSSCKFWMechanism *fwMechanism,
240 NSSCKFWMechanism *fwMechanism, 221 CK_RV *pError)
241 CK_RV *pError
242 )
243 { 222 {
244 if (!fwMechanism->mdMechanism->DigestInit) { 223 if (!fwMechanism->mdMechanism->DigestInit) {
245 return CK_FALSE; 224 return CK_FALSE;
246 } 225 }
247 return CK_TRUE; 226 return CK_TRUE;
248 } 227 }
249 228
250 /* 229 /*
251 * nssCKFWMechanism_GetCanSign 230 * nssCKFWMechanism_GetCanSign
252 * 231 *
253 */ 232 */
254 NSS_EXTERN CK_BBOOL 233 NSS_EXTERN CK_BBOOL
255 nssCKFWMechanism_GetCanSign 234 nssCKFWMechanism_GetCanSign(
256 ( 235 NSSCKFWMechanism *fwMechanism,
257 NSSCKFWMechanism *fwMechanism, 236 CK_RV *pError)
258 CK_RV *pError
259 )
260 { 237 {
261 if (!fwMechanism->mdMechanism->SignInit) { 238 if (!fwMechanism->mdMechanism->SignInit) {
262 return CK_FALSE; 239 return CK_FALSE;
263 } 240 }
264 return CK_TRUE; 241 return CK_TRUE;
265 } 242 }
266 243
267 /* 244 /*
268 * nssCKFWMechanism_GetCanSignRecover 245 * nssCKFWMechanism_GetCanSignRecover
269 * 246 *
270 */ 247 */
271 NSS_EXTERN CK_BBOOL 248 NSS_EXTERN CK_BBOOL
272 nssCKFWMechanism_GetCanSignRecover 249 nssCKFWMechanism_GetCanSignRecover(
273 ( 250 NSSCKFWMechanism *fwMechanism,
274 NSSCKFWMechanism *fwMechanism, 251 CK_RV *pError)
275 CK_RV *pError
276 )
277 { 252 {
278 if (!fwMechanism->mdMechanism->SignRecoverInit) { 253 if (!fwMechanism->mdMechanism->SignRecoverInit) {
279 return CK_FALSE; 254 return CK_FALSE;
280 } 255 }
281 return CK_TRUE; 256 return CK_TRUE;
282 } 257 }
283 258
284 /* 259 /*
285 * nssCKFWMechanism_GetCanVerify 260 * nssCKFWMechanism_GetCanVerify
286 * 261 *
287 */ 262 */
288 NSS_EXTERN CK_BBOOL 263 NSS_EXTERN CK_BBOOL
289 nssCKFWMechanism_GetCanVerify 264 nssCKFWMechanism_GetCanVerify(
290 ( 265 NSSCKFWMechanism *fwMechanism,
291 NSSCKFWMechanism *fwMechanism, 266 CK_RV *pError)
292 CK_RV *pError
293 )
294 { 267 {
295 if (!fwMechanism->mdMechanism->VerifyInit) { 268 if (!fwMechanism->mdMechanism->VerifyInit) {
296 return CK_FALSE; 269 return CK_FALSE;
297 } 270 }
298 return CK_TRUE; 271 return CK_TRUE;
299 } 272 }
300 273
301 /* 274 /*
302 * nssCKFWMechanism_GetCanVerifyRecover 275 * nssCKFWMechanism_GetCanVerifyRecover
303 * 276 *
304 */ 277 */
305 NSS_EXTERN CK_BBOOL 278 NSS_EXTERN CK_BBOOL
306 nssCKFWMechanism_GetCanVerifyRecover 279 nssCKFWMechanism_GetCanVerifyRecover(
307 ( 280 NSSCKFWMechanism *fwMechanism,
308 NSSCKFWMechanism *fwMechanism, 281 CK_RV *pError)
309 CK_RV *pError
310 )
311 { 282 {
312 if (!fwMechanism->mdMechanism->VerifyRecoverInit) { 283 if (!fwMechanism->mdMechanism->VerifyRecoverInit) {
313 return CK_FALSE; 284 return CK_FALSE;
314 } 285 }
315 return CK_TRUE; 286 return CK_TRUE;
316 } 287 }
317 288
318 /* 289 /*
319 * nssCKFWMechanism_GetCanGenerate 290 * nssCKFWMechanism_GetCanGenerate
320 * 291 *
321 */ 292 */
322 NSS_EXTERN CK_BBOOL 293 NSS_EXTERN CK_BBOOL
323 nssCKFWMechanism_GetCanGenerate 294 nssCKFWMechanism_GetCanGenerate(
324 ( 295 NSSCKFWMechanism *fwMechanism,
325 NSSCKFWMechanism *fwMechanism, 296 CK_RV *pError)
326 CK_RV *pError
327 )
328 { 297 {
329 if (!fwMechanism->mdMechanism->GenerateKey) { 298 if (!fwMechanism->mdMechanism->GenerateKey) {
330 return CK_FALSE; 299 return CK_FALSE;
331 } 300 }
332 return CK_TRUE; 301 return CK_TRUE;
333 } 302 }
334 303
335 /* 304 /*
336 * nssCKFWMechanism_GetCanGenerateKeyPair 305 * nssCKFWMechanism_GetCanGenerateKeyPair
337 * 306 *
338 */ 307 */
339 NSS_EXTERN CK_BBOOL 308 NSS_EXTERN CK_BBOOL
340 nssCKFWMechanism_GetCanGenerateKeyPair 309 nssCKFWMechanism_GetCanGenerateKeyPair(
341 ( 310 NSSCKFWMechanism *fwMechanism,
342 NSSCKFWMechanism *fwMechanism, 311 CK_RV *pError)
343 CK_RV *pError
344 )
345 { 312 {
346 if (!fwMechanism->mdMechanism->GenerateKeyPair) { 313 if (!fwMechanism->mdMechanism->GenerateKeyPair) {
347 return CK_FALSE; 314 return CK_FALSE;
348 } 315 }
349 return CK_TRUE; 316 return CK_TRUE;
350 } 317 }
351 318
352 /* 319 /*
353 * nssCKFWMechanism_GetCanUnwrap 320 * nssCKFWMechanism_GetCanUnwrap
354 * 321 *
355 */ 322 */
356 NSS_EXTERN CK_BBOOL 323 NSS_EXTERN CK_BBOOL
357 nssCKFWMechanism_GetCanUnwrap 324 nssCKFWMechanism_GetCanUnwrap(
358 ( 325 NSSCKFWMechanism *fwMechanism,
359 NSSCKFWMechanism *fwMechanism, 326 CK_RV *pError)
360 CK_RV *pError
361 )
362 { 327 {
363 if (!fwMechanism->mdMechanism->UnwrapKey) { 328 if (!fwMechanism->mdMechanism->UnwrapKey) {
364 return CK_FALSE; 329 return CK_FALSE;
365 } 330 }
366 return CK_TRUE; 331 return CK_TRUE;
367 } 332 }
368 333
369 /* 334 /*
370 * nssCKFWMechanism_GetCanWrap 335 * nssCKFWMechanism_GetCanWrap
371 * 336 *
372 */ 337 */
373 NSS_EXTERN CK_BBOOL 338 NSS_EXTERN CK_BBOOL
374 nssCKFWMechanism_GetCanWrap 339 nssCKFWMechanism_GetCanWrap(
375 ( 340 NSSCKFWMechanism *fwMechanism,
376 NSSCKFWMechanism *fwMechanism, 341 CK_RV *pError)
377 CK_RV *pError
378 )
379 { 342 {
380 if (!fwMechanism->mdMechanism->WrapKey) { 343 if (!fwMechanism->mdMechanism->WrapKey) {
381 return CK_FALSE; 344 return CK_FALSE;
382 } 345 }
383 return CK_TRUE; 346 return CK_TRUE;
384 } 347 }
385 348
386 /* 349 /*
387 * nssCKFWMechanism_GetCanDerive 350 * nssCKFWMechanism_GetCanDerive
388 * 351 *
389 */ 352 */
390 NSS_EXTERN CK_BBOOL 353 NSS_EXTERN CK_BBOOL
391 nssCKFWMechanism_GetCanDerive 354 nssCKFWMechanism_GetCanDerive(
392 ( 355 NSSCKFWMechanism *fwMechanism,
393 NSSCKFWMechanism *fwMechanism, 356 CK_RV *pError)
394 CK_RV *pError
395 )
396 { 357 {
397 if (!fwMechanism->mdMechanism->DeriveKey) { 358 if (!fwMechanism->mdMechanism->DeriveKey) {
398 return CK_FALSE; 359 return CK_FALSE;
399 } 360 }
400 return CK_TRUE; 361 return CK_TRUE;
401 } 362 }
402 363
403 /* 364 /*
404 * These are the actual crypto operations 365 * These are the actual crypto operations
405 */ 366 */
406 367
407 /* 368 /*
408 * nssCKFWMechanism_EncryptInit 369 * nssCKFWMechanism_EncryptInit
409 * Start an encryption session. 370 * Start an encryption session.
410 */ 371 */
411 NSS_EXTERN CK_RV 372 NSS_EXTERN CK_RV
412 nssCKFWMechanism_EncryptInit 373 nssCKFWMechanism_EncryptInit(
413 ( 374 NSSCKFWMechanism *fwMechanism,
414 NSSCKFWMechanism *fwMechanism, 375 CK_MECHANISM *pMechanism,
415 CK_MECHANISM *pMechanism, 376 NSSCKFWSession *fwSession,
416 NSSCKFWSession *fwSession, 377 NSSCKFWObject *fwObject)
417 NSSCKFWObject *fwObject
418 )
419 { 378 {
420 NSSCKFWCryptoOperation *fwOperation; 379 NSSCKFWCryptoOperation *fwOperation;
421 NSSCKMDCryptoOperation *mdOperation; 380 NSSCKMDCryptoOperation *mdOperation;
422 NSSCKMDSession *mdSession; 381 NSSCKMDSession *mdSession;
423 NSSCKMDObject *mdObject; 382 NSSCKMDObject *mdObject;
424 CK_RV error = CKR_OK; 383 CK_RV error = CKR_OK;
425 384
385 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession,
386 NSSCKFWCryptoOperatio nState_EncryptDecrypt);
387 if (fwOperation) {
388 return CKR_OPERATION_ACTIVE;
389 }
426 390
427 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession, 391 if (!fwMechanism->mdMechanism->EncryptInit) {
428 NSSCKFWCryptoOperationState_EncryptDecrypt); 392 return CKR_FUNCTION_FAILED;
429 if (fwOperation) { 393 }
430 return CKR_OPERATION_ACTIVE;
431 }
432 394
433 if (!fwMechanism->mdMechanism->EncryptInit) { 395 mdSession = nssCKFWSession_GetMDSession(fwSession);
434 return CKR_FUNCTION_FAILED; 396 mdObject = nssCKFWObject_GetMDObject(fwObject);
435 } 397 mdOperation = fwMechanism->mdMechanism->EncryptInit(
436
437 mdSession = nssCKFWSession_GetMDSession(fwSession);
438 mdObject = nssCKFWObject_GetMDObject(fwObject);
439 mdOperation = fwMechanism->mdMechanism->EncryptInit(
440 fwMechanism->mdMechanism, 398 fwMechanism->mdMechanism,
441 fwMechanism, 399 fwMechanism,
442 pMechanism, 400 pMechanism,
443 mdSession, 401 mdSession,
444 fwSession, 402 fwSession,
445 fwMechanism->mdToken, 403 fwMechanism->mdToken,
446 fwMechanism->fwToken, 404 fwMechanism->fwToken,
447 fwMechanism->mdInstance, 405 fwMechanism->mdInstance,
448 fwMechanism->fwInstance, 406 fwMechanism->fwInstance,
449 mdObject, 407 mdObject,
450 fwObject, 408 fwObject,
451 &error 409 &error);
452 ); 410 if (!mdOperation) {
453 if (!mdOperation) { 411 goto loser;
454 goto loser; 412 }
455 }
456 413
457 fwOperation = nssCKFWCryptoOperation_Create(mdOperation, 414 fwOperation = nssCKFWCryptoOperation_Create(mdOperation,
458 mdSession, fwSession, fwMechanism->mdToken, fwMechanism->fwToken, 415 mdSession, fwSession, fwMechanis m->mdToken, fwMechanism->fwToken,
459 fwMechanism->mdInstance, fwMechanism->fwInstance, 416 fwMechanism->mdInstance, fwMecha nism->fwInstance,
460 NSSCKFWCryptoOperationType_Encrypt, &error); 417 NSSCKFWCryptoOperationType_Encry pt, &error);
461 if (fwOperation) { 418 if (fwOperation) {
462 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation, 419 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation,
463 NSSCKFWCryptoOperationState_EncryptDecrypt); 420 NSSCKFWCryptoOperationState_Enc ryptDecrypt);
464 } 421 }
465 422
466 loser: 423 loser:
467 return error; 424 return error;
468 } 425 }
469 426
470 /* 427 /*
471 * nssCKFWMechanism_DecryptInit 428 * nssCKFWMechanism_DecryptInit
472 * Start an encryption session. 429 * Start an encryption session.
473 */ 430 */
474 NSS_EXTERN CK_RV 431 NSS_EXTERN CK_RV
475 nssCKFWMechanism_DecryptInit 432 nssCKFWMechanism_DecryptInit(
476 ( 433 NSSCKFWMechanism *fwMechanism,
477 NSSCKFWMechanism *fwMechanism, 434 CK_MECHANISM *pMechanism,
478 CK_MECHANISM *pMechanism, 435 NSSCKFWSession *fwSession,
479 NSSCKFWSession *fwSession, 436 NSSCKFWObject *fwObject)
480 NSSCKFWObject *fwObject
481 )
482 { 437 {
483 NSSCKFWCryptoOperation *fwOperation; 438 NSSCKFWCryptoOperation *fwOperation;
484 NSSCKMDCryptoOperation *mdOperation; 439 NSSCKMDCryptoOperation *mdOperation;
485 NSSCKMDSession *mdSession; 440 NSSCKMDSession *mdSession;
486 NSSCKMDObject *mdObject; 441 NSSCKMDObject *mdObject;
487 CK_RV error = CKR_OK; 442 CK_RV error = CKR_OK;
488 443
444 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession,
445 NSSCKFWCryptoOperatio nState_EncryptDecrypt);
446 if (fwOperation) {
447 return CKR_OPERATION_ACTIVE;
448 }
489 449
490 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession, 450 if (!fwMechanism->mdMechanism->DecryptInit) {
491 NSSCKFWCryptoOperationState_EncryptDecrypt); 451 return CKR_FUNCTION_FAILED;
492 if (fwOperation) { 452 }
493 return CKR_OPERATION_ACTIVE;
494 }
495 453
496 if (!fwMechanism->mdMechanism->DecryptInit) { 454 mdSession = nssCKFWSession_GetMDSession(fwSession);
497 return CKR_FUNCTION_FAILED; 455 mdObject = nssCKFWObject_GetMDObject(fwObject);
498 } 456 mdOperation = fwMechanism->mdMechanism->DecryptInit(
499
500 mdSession = nssCKFWSession_GetMDSession(fwSession);
501 mdObject = nssCKFWObject_GetMDObject(fwObject);
502 mdOperation = fwMechanism->mdMechanism->DecryptInit(
503 fwMechanism->mdMechanism, 457 fwMechanism->mdMechanism,
504 fwMechanism, 458 fwMechanism,
505 pMechanism, 459 pMechanism,
506 mdSession, 460 mdSession,
507 fwSession, 461 fwSession,
508 fwMechanism->mdToken, 462 fwMechanism->mdToken,
509 fwMechanism->fwToken, 463 fwMechanism->fwToken,
510 fwMechanism->mdInstance, 464 fwMechanism->mdInstance,
511 fwMechanism->fwInstance, 465 fwMechanism->fwInstance,
512 mdObject, 466 mdObject,
513 fwObject, 467 fwObject,
514 &error 468 &error);
515 ); 469 if (!mdOperation) {
516 if (!mdOperation) { 470 goto loser;
517 goto loser; 471 }
518 }
519 472
520 fwOperation = nssCKFWCryptoOperation_Create(mdOperation, 473 fwOperation = nssCKFWCryptoOperation_Create(mdOperation,
521 mdSession, fwSession, fwMechanism->mdToken, fwMechanism->fwToken, 474 mdSession, fwSession, fwMechanis m->mdToken, fwMechanism->fwToken,
522 fwMechanism->mdInstance, fwMechanism->fwInstance, 475 fwMechanism->mdInstance, fwMecha nism->fwInstance,
523 NSSCKFWCryptoOperationType_Decrypt, &error); 476 NSSCKFWCryptoOperationType_Decry pt, &error);
524 if (fwOperation) { 477 if (fwOperation) {
525 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation, 478 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation,
526 NSSCKFWCryptoOperationState_EncryptDecrypt); 479 NSSCKFWCryptoOperationState_Enc ryptDecrypt);
527 } 480 }
528 481
529 loser: 482 loser:
530 return error; 483 return error;
531 } 484 }
532 485
533 /* 486 /*
534 * nssCKFWMechanism_DigestInit 487 * nssCKFWMechanism_DigestInit
535 * Start an encryption session. 488 * Start an encryption session.
536 */ 489 */
537 NSS_EXTERN CK_RV 490 NSS_EXTERN CK_RV
538 nssCKFWMechanism_DigestInit 491 nssCKFWMechanism_DigestInit(
539 ( 492 NSSCKFWMechanism *fwMechanism,
540 NSSCKFWMechanism *fwMechanism, 493 CK_MECHANISM *pMechanism,
541 CK_MECHANISM *pMechanism, 494 NSSCKFWSession *fwSession)
542 NSSCKFWSession *fwSession
543 )
544 { 495 {
545 NSSCKFWCryptoOperation *fwOperation; 496 NSSCKFWCryptoOperation *fwOperation;
546 NSSCKMDCryptoOperation *mdOperation; 497 NSSCKMDCryptoOperation *mdOperation;
547 NSSCKMDSession *mdSession; 498 NSSCKMDSession *mdSession;
548 CK_RV error = CKR_OK; 499 CK_RV error = CKR_OK;
549 500
501 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession,
502 NSSCKFWCryptoOperatio nState_Digest);
503 if (fwOperation) {
504 return CKR_OPERATION_ACTIVE;
505 }
550 506
551 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession, 507 if (!fwMechanism->mdMechanism->DigestInit) {
552 NSSCKFWCryptoOperationState_Digest); 508 return CKR_FUNCTION_FAILED;
553 if (fwOperation) { 509 }
554 return CKR_OPERATION_ACTIVE;
555 }
556 510
557 if (!fwMechanism->mdMechanism->DigestInit) { 511 mdSession = nssCKFWSession_GetMDSession(fwSession);
558 return CKR_FUNCTION_FAILED; 512 mdOperation = fwMechanism->mdMechanism->DigestInit(
559 }
560
561 mdSession = nssCKFWSession_GetMDSession(fwSession);
562 mdOperation = fwMechanism->mdMechanism->DigestInit(
563 fwMechanism->mdMechanism, 513 fwMechanism->mdMechanism,
564 fwMechanism, 514 fwMechanism,
565 pMechanism, 515 pMechanism,
566 mdSession, 516 mdSession,
567 fwSession, 517 fwSession,
568 fwMechanism->mdToken, 518 fwMechanism->mdToken,
569 fwMechanism->fwToken, 519 fwMechanism->fwToken,
570 fwMechanism->mdInstance, 520 fwMechanism->mdInstance,
571 fwMechanism->fwInstance, 521 fwMechanism->fwInstance,
572 &error 522 &error);
573 ); 523 if (!mdOperation) {
574 if (!mdOperation) { 524 goto loser;
575 goto loser; 525 }
576 }
577 526
578 fwOperation = nssCKFWCryptoOperation_Create(mdOperation, 527 fwOperation = nssCKFWCryptoOperation_Create(mdOperation,
579 mdSession, fwSession, fwMechanism->mdToken, fwMechanism->fwToken, 528 mdSession, fwSession, fwMechanis m->mdToken, fwMechanism->fwToken,
580 fwMechanism->mdInstance, fwMechanism->fwInstance, 529 fwMechanism->mdInstance, fwMecha nism->fwInstance,
581 NSSCKFWCryptoOperationType_Digest, &error); 530 NSSCKFWCryptoOperationType_Diges t, &error);
582 if (fwOperation) { 531 if (fwOperation) {
583 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation, 532 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation,
584 NSSCKFWCryptoOperationState_Digest); 533 NSSCKFWCryptoOperationState_Dig est);
585 } 534 }
586 535
587 loser: 536 loser:
588 return error; 537 return error;
589 } 538 }
590 539
591 /* 540 /*
592 * nssCKFWMechanism_SignInit 541 * nssCKFWMechanism_SignInit
593 * Start an encryption session. 542 * Start an encryption session.
594 */ 543 */
595 NSS_EXTERN CK_RV 544 NSS_EXTERN CK_RV
596 nssCKFWMechanism_SignInit 545 nssCKFWMechanism_SignInit(
597 ( 546 NSSCKFWMechanism *fwMechanism,
598 NSSCKFWMechanism *fwMechanism, 547 CK_MECHANISM *pMechanism,
599 CK_MECHANISM *pMechanism, 548 NSSCKFWSession *fwSession,
600 NSSCKFWSession *fwSession, 549 NSSCKFWObject *fwObject)
601 NSSCKFWObject *fwObject
602 )
603 { 550 {
604 NSSCKFWCryptoOperation *fwOperation; 551 NSSCKFWCryptoOperation *fwOperation;
605 NSSCKMDCryptoOperation *mdOperation; 552 NSSCKMDCryptoOperation *mdOperation;
606 NSSCKMDSession *mdSession; 553 NSSCKMDSession *mdSession;
607 NSSCKMDObject *mdObject; 554 NSSCKMDObject *mdObject;
608 CK_RV error = CKR_OK; 555 CK_RV error = CKR_OK;
609 556
557 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession,
558 NSSCKFWCryptoOperatio nState_SignVerify);
559 if (fwOperation) {
560 return CKR_OPERATION_ACTIVE;
561 }
610 562
611 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession, 563 if (!fwMechanism->mdMechanism->SignInit) {
612 NSSCKFWCryptoOperationState_SignVerify); 564 return CKR_FUNCTION_FAILED;
613 if (fwOperation) { 565 }
614 return CKR_OPERATION_ACTIVE;
615 }
616 566
617 if (!fwMechanism->mdMechanism->SignInit) { 567 mdSession = nssCKFWSession_GetMDSession(fwSession);
618 return CKR_FUNCTION_FAILED; 568 mdObject = nssCKFWObject_GetMDObject(fwObject);
619 } 569 mdOperation = fwMechanism->mdMechanism->SignInit(
620
621 mdSession = nssCKFWSession_GetMDSession(fwSession);
622 mdObject = nssCKFWObject_GetMDObject(fwObject);
623 mdOperation = fwMechanism->mdMechanism->SignInit(
624 fwMechanism->mdMechanism, 570 fwMechanism->mdMechanism,
625 fwMechanism, 571 fwMechanism,
626 pMechanism, 572 pMechanism,
627 mdSession, 573 mdSession,
628 fwSession, 574 fwSession,
629 fwMechanism->mdToken, 575 fwMechanism->mdToken,
630 fwMechanism->fwToken, 576 fwMechanism->fwToken,
631 fwMechanism->mdInstance, 577 fwMechanism->mdInstance,
632 fwMechanism->fwInstance, 578 fwMechanism->fwInstance,
633 mdObject, 579 mdObject,
634 fwObject, 580 fwObject,
635 &error 581 &error);
636 ); 582 if (!mdOperation) {
637 if (!mdOperation) { 583 goto loser;
638 goto loser; 584 }
639 }
640 585
641 fwOperation = nssCKFWCryptoOperation_Create(mdOperation, 586 fwOperation = nssCKFWCryptoOperation_Create(mdOperation,
642 mdSession, fwSession, fwMechanism->mdToken, fwMechanism->fwToken, 587 mdSession, fwSession, fwMechanis m->mdToken, fwMechanism->fwToken,
643 fwMechanism->mdInstance, fwMechanism->fwInstance, 588 fwMechanism->mdInstance, fwMecha nism->fwInstance,
644 NSSCKFWCryptoOperationType_Sign, &error); 589 NSSCKFWCryptoOperationType_Sign, &error);
645 if (fwOperation) { 590 if (fwOperation) {
646 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation, 591 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation,
647 NSSCKFWCryptoOperationState_SignVerify); 592 NSSCKFWCryptoOperationState_Sig nVerify);
648 } 593 }
649 594
650 loser: 595 loser:
651 return error; 596 return error;
652 } 597 }
653 598
654 /* 599 /*
655 * nssCKFWMechanism_VerifyInit 600 * nssCKFWMechanism_VerifyInit
656 * Start an encryption session. 601 * Start an encryption session.
657 */ 602 */
658 NSS_EXTERN CK_RV 603 NSS_EXTERN CK_RV
659 nssCKFWMechanism_VerifyInit 604 nssCKFWMechanism_VerifyInit(
660 ( 605 NSSCKFWMechanism *fwMechanism,
661 NSSCKFWMechanism *fwMechanism, 606 CK_MECHANISM *pMechanism,
662 CK_MECHANISM *pMechanism, 607 NSSCKFWSession *fwSession,
663 NSSCKFWSession *fwSession, 608 NSSCKFWObject *fwObject)
664 NSSCKFWObject *fwObject
665 )
666 { 609 {
667 NSSCKFWCryptoOperation *fwOperation; 610 NSSCKFWCryptoOperation *fwOperation;
668 NSSCKMDCryptoOperation *mdOperation; 611 NSSCKMDCryptoOperation *mdOperation;
669 NSSCKMDSession *mdSession; 612 NSSCKMDSession *mdSession;
670 NSSCKMDObject *mdObject; 613 NSSCKMDObject *mdObject;
671 CK_RV error = CKR_OK; 614 CK_RV error = CKR_OK;
672 615
616 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession,
617 NSSCKFWCryptoOperatio nState_SignVerify);
618 if (fwOperation) {
619 return CKR_OPERATION_ACTIVE;
620 }
673 621
674 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession, 622 if (!fwMechanism->mdMechanism->VerifyInit) {
675 NSSCKFWCryptoOperationState_SignVerify); 623 return CKR_FUNCTION_FAILED;
676 if (fwOperation) { 624 }
677 return CKR_OPERATION_ACTIVE;
678 }
679 625
680 if (!fwMechanism->mdMechanism->VerifyInit) { 626 mdSession = nssCKFWSession_GetMDSession(fwSession);
681 return CKR_FUNCTION_FAILED; 627 mdObject = nssCKFWObject_GetMDObject(fwObject);
682 } 628 mdOperation = fwMechanism->mdMechanism->VerifyInit(
683
684 mdSession = nssCKFWSession_GetMDSession(fwSession);
685 mdObject = nssCKFWObject_GetMDObject(fwObject);
686 mdOperation = fwMechanism->mdMechanism->VerifyInit(
687 fwMechanism->mdMechanism, 629 fwMechanism->mdMechanism,
688 fwMechanism, 630 fwMechanism,
689 pMechanism, 631 pMechanism,
690 mdSession, 632 mdSession,
691 fwSession, 633 fwSession,
692 fwMechanism->mdToken, 634 fwMechanism->mdToken,
693 fwMechanism->fwToken, 635 fwMechanism->fwToken,
694 fwMechanism->mdInstance, 636 fwMechanism->mdInstance,
695 fwMechanism->fwInstance, 637 fwMechanism->fwInstance,
696 mdObject, 638 mdObject,
697 fwObject, 639 fwObject,
698 &error 640 &error);
699 ); 641 if (!mdOperation) {
700 if (!mdOperation) { 642 goto loser;
701 goto loser; 643 }
702 }
703 644
704 fwOperation = nssCKFWCryptoOperation_Create(mdOperation, 645 fwOperation = nssCKFWCryptoOperation_Create(mdOperation,
705 mdSession, fwSession, fwMechanism->mdToken, fwMechanism->fwToken, 646 mdSession, fwSession, fwMechanis m->mdToken, fwMechanism->fwToken,
706 fwMechanism->mdInstance, fwMechanism->fwInstance, 647 fwMechanism->mdInstance, fwMecha nism->fwInstance,
707 NSSCKFWCryptoOperationType_Verify, &error); 648 NSSCKFWCryptoOperationType_Verif y, &error);
708 if (fwOperation) { 649 if (fwOperation) {
709 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation, 650 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation,
710 NSSCKFWCryptoOperationState_SignVerify); 651 NSSCKFWCryptoOperationState_Sig nVerify);
711 } 652 }
712 653
713 loser: 654 loser:
714 return error; 655 return error;
715 } 656 }
716 657
717 /* 658 /*
718 * nssCKFWMechanism_SignRecoverInit 659 * nssCKFWMechanism_SignRecoverInit
719 * Start an encryption session. 660 * Start an encryption session.
720 */ 661 */
721 NSS_EXTERN CK_RV 662 NSS_EXTERN CK_RV
722 nssCKFWMechanism_SignRecoverInit 663 nssCKFWMechanism_SignRecoverInit(
723 ( 664 NSSCKFWMechanism *fwMechanism,
724 NSSCKFWMechanism *fwMechanism, 665 CK_MECHANISM *pMechanism,
725 CK_MECHANISM *pMechanism, 666 NSSCKFWSession *fwSession,
726 NSSCKFWSession *fwSession, 667 NSSCKFWObject *fwObject)
727 NSSCKFWObject *fwObject
728 )
729 { 668 {
730 NSSCKFWCryptoOperation *fwOperation; 669 NSSCKFWCryptoOperation *fwOperation;
731 NSSCKMDCryptoOperation *mdOperation; 670 NSSCKMDCryptoOperation *mdOperation;
732 NSSCKMDSession *mdSession; 671 NSSCKMDSession *mdSession;
733 NSSCKMDObject *mdObject; 672 NSSCKMDObject *mdObject;
734 CK_RV error = CKR_OK; 673 CK_RV error = CKR_OK;
735 674
675 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession,
676 NSSCKFWCryptoOperatio nState_SignVerify);
677 if (fwOperation) {
678 return CKR_OPERATION_ACTIVE;
679 }
736 680
737 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession, 681 if (!fwMechanism->mdMechanism->SignRecoverInit) {
738 NSSCKFWCryptoOperationState_SignVerify); 682 return CKR_FUNCTION_FAILED;
739 if (fwOperation) { 683 }
740 return CKR_OPERATION_ACTIVE;
741 }
742 684
743 if (!fwMechanism->mdMechanism->SignRecoverInit) { 685 mdSession = nssCKFWSession_GetMDSession(fwSession);
744 return CKR_FUNCTION_FAILED; 686 mdObject = nssCKFWObject_GetMDObject(fwObject);
745 } 687 mdOperation = fwMechanism->mdMechanism->SignRecoverInit(
746
747 mdSession = nssCKFWSession_GetMDSession(fwSession);
748 mdObject = nssCKFWObject_GetMDObject(fwObject);
749 mdOperation = fwMechanism->mdMechanism->SignRecoverInit(
750 fwMechanism->mdMechanism, 688 fwMechanism->mdMechanism,
751 fwMechanism, 689 fwMechanism,
752 pMechanism, 690 pMechanism,
753 mdSession, 691 mdSession,
754 fwSession, 692 fwSession,
755 fwMechanism->mdToken, 693 fwMechanism->mdToken,
756 fwMechanism->fwToken, 694 fwMechanism->fwToken,
757 fwMechanism->mdInstance, 695 fwMechanism->mdInstance,
758 fwMechanism->fwInstance, 696 fwMechanism->fwInstance,
759 mdObject, 697 mdObject,
760 fwObject, 698 fwObject,
761 &error 699 &error);
762 ); 700 if (!mdOperation) {
763 if (!mdOperation) { 701 goto loser;
764 goto loser; 702 }
765 }
766 703
767 fwOperation = nssCKFWCryptoOperation_Create(mdOperation, 704 fwOperation = nssCKFWCryptoOperation_Create(mdOperation,
768 mdSession, fwSession, fwMechanism->mdToken, fwMechanism->fwToken, 705 mdSession, fwSession, fwMechanis m->mdToken, fwMechanism->fwToken,
769 fwMechanism->mdInstance, fwMechanism->fwInstance, 706 fwMechanism->mdInstance, fwMecha nism->fwInstance,
770 NSSCKFWCryptoOperationType_SignRecover, &error); 707 NSSCKFWCryptoOperationType_SignR ecover, &error);
771 if (fwOperation) { 708 if (fwOperation) {
772 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation, 709 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation,
773 NSSCKFWCryptoOperationState_SignVerify); 710 NSSCKFWCryptoOperationState_Sig nVerify);
774 } 711 }
775 712
776 loser: 713 loser:
777 return error; 714 return error;
778 } 715 }
779 716
780 /* 717 /*
781 * nssCKFWMechanism_VerifyRecoverInit 718 * nssCKFWMechanism_VerifyRecoverInit
782 * Start an encryption session. 719 * Start an encryption session.
783 */ 720 */
784 NSS_EXTERN CK_RV 721 NSS_EXTERN CK_RV
785 nssCKFWMechanism_VerifyRecoverInit 722 nssCKFWMechanism_VerifyRecoverInit(
786 ( 723 NSSCKFWMechanism *fwMechanism,
787 NSSCKFWMechanism *fwMechanism, 724 CK_MECHANISM *pMechanism,
788 CK_MECHANISM *pMechanism, 725 NSSCKFWSession *fwSession,
789 NSSCKFWSession *fwSession, 726 NSSCKFWObject *fwObject)
790 NSSCKFWObject *fwObject
791 )
792 { 727 {
793 NSSCKFWCryptoOperation *fwOperation; 728 NSSCKFWCryptoOperation *fwOperation;
794 NSSCKMDCryptoOperation *mdOperation; 729 NSSCKMDCryptoOperation *mdOperation;
795 NSSCKMDSession *mdSession; 730 NSSCKMDSession *mdSession;
796 NSSCKMDObject *mdObject; 731 NSSCKMDObject *mdObject;
797 CK_RV error = CKR_OK; 732 CK_RV error = CKR_OK;
798 733
734 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession,
735 NSSCKFWCryptoOperatio nState_SignVerify);
736 if (fwOperation) {
737 return CKR_OPERATION_ACTIVE;
738 }
799 739
800 fwOperation = nssCKFWSession_GetCurrentCryptoOperation(fwSession, 740 if (!fwMechanism->mdMechanism->VerifyRecoverInit) {
801 NSSCKFWCryptoOperationState_SignVerify); 741 return CKR_FUNCTION_FAILED;
802 if (fwOperation) { 742 }
803 return CKR_OPERATION_ACTIVE;
804 }
805 743
806 if (!fwMechanism->mdMechanism->VerifyRecoverInit) { 744 mdSession = nssCKFWSession_GetMDSession(fwSession);
807 return CKR_FUNCTION_FAILED; 745 mdObject = nssCKFWObject_GetMDObject(fwObject);
808 } 746 mdOperation = fwMechanism->mdMechanism->VerifyRecoverInit(
809
810 mdSession = nssCKFWSession_GetMDSession(fwSession);
811 mdObject = nssCKFWObject_GetMDObject(fwObject);
812 mdOperation = fwMechanism->mdMechanism->VerifyRecoverInit(
813 fwMechanism->mdMechanism, 747 fwMechanism->mdMechanism,
814 fwMechanism, 748 fwMechanism,
815 pMechanism, 749 pMechanism,
816 mdSession, 750 mdSession,
817 fwSession, 751 fwSession,
818 fwMechanism->mdToken, 752 fwMechanism->mdToken,
819 fwMechanism->fwToken, 753 fwMechanism->fwToken,
820 fwMechanism->mdInstance, 754 fwMechanism->mdInstance,
821 fwMechanism->fwInstance, 755 fwMechanism->fwInstance,
822 mdObject, 756 mdObject,
823 fwObject, 757 fwObject,
824 &error 758 &error);
825 ); 759 if (!mdOperation) {
826 if (!mdOperation) { 760 goto loser;
827 goto loser; 761 }
828 }
829 762
830 fwOperation = nssCKFWCryptoOperation_Create(mdOperation, 763 fwOperation = nssCKFWCryptoOperation_Create(mdOperation,
831 mdSession, fwSession, fwMechanism->mdToken, fwMechanism->fwToken, 764 mdSession, fwSession, fwMechanis m->mdToken, fwMechanism->fwToken,
832 fwMechanism->mdInstance, fwMechanism->fwInstance, 765 fwMechanism->mdInstance, fwMecha nism->fwInstance,
833 NSSCKFWCryptoOperationType_VerifyRecover, &error); 766 NSSCKFWCryptoOperationType_Verif yRecover, &error);
834 if (fwOperation) { 767 if (fwOperation) {
835 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation, 768 nssCKFWSession_SetCurrentCryptoOperation(fwSession, fwOperation,
836 NSSCKFWCryptoOperationState_SignVerify); 769 NSSCKFWCryptoOperationState_Sig nVerify);
837 } 770 }
838 771
839 loser: 772 loser:
840 return error; 773 return error;
841 } 774 }
842 775
843 /* 776 /*
844 * nssCKFWMechanism_GenerateKey 777 * nssCKFWMechanism_GenerateKey
845 */ 778 */
846 NSS_EXTERN NSSCKFWObject * 779 NSS_EXTERN NSSCKFWObject *
847 nssCKFWMechanism_GenerateKey 780 nssCKFWMechanism_GenerateKey(
848 ( 781 NSSCKFWMechanism *fwMechanism,
849 NSSCKFWMechanism *fwMechanism, 782 CK_MECHANISM_PTR pMechanism,
850 CK_MECHANISM_PTR pMechanism, 783 NSSCKFWSession *fwSession,
851 NSSCKFWSession *fwSession, 784 CK_ATTRIBUTE_PTR pTemplate,
852 CK_ATTRIBUTE_PTR pTemplate, 785 CK_ULONG ulAttributeCount,
853 CK_ULONG ulAttributeCount, 786 CK_RV *pError)
854 CK_RV *pError
855 )
856 { 787 {
857 NSSCKMDSession *mdSession; 788 NSSCKMDSession *mdSession;
858 NSSCKMDObject *mdObject; 789 NSSCKMDObject *mdObject;
859 NSSCKFWObject *fwObject = NULL; 790 NSSCKFWObject *fwObject = NULL;
860 NSSArena *arena; 791 NSSArena *arena;
861 792
862 if (!fwMechanism->mdMechanism->GenerateKey) { 793 if (!fwMechanism->mdMechanism->GenerateKey) {
863 *pError = CKR_FUNCTION_FAILED; 794 *pError = CKR_FUNCTION_FAILED;
864 return (NSSCKFWObject *)NULL; 795 return (NSSCKFWObject *)NULL;
865 } 796 }
866 797
867 arena = nssCKFWToken_GetArena(fwMechanism->fwToken, pError); 798 arena = nssCKFWToken_GetArena(fwMechanism->fwToken, pError);
868 if (!arena) { 799 if (!arena) {
869 if (CKR_OK == *pError) { 800 if (CKR_OK == *pError) {
870 *pError = CKR_GENERAL_ERROR; 801 *pError = CKR_GENERAL_ERROR;
802 }
803 return (NSSCKFWObject *)NULL;
871 } 804 }
872 return (NSSCKFWObject *)NULL;
873 }
874 805
875 mdSession = nssCKFWSession_GetMDSession(fwSession); 806 mdSession = nssCKFWSession_GetMDSession(fwSession);
876 mdObject = fwMechanism->mdMechanism->GenerateKey( 807 mdObject = fwMechanism->mdMechanism->GenerateKey(
877 fwMechanism->mdMechanism, 808 fwMechanism->mdMechanism,
878 fwMechanism, 809 fwMechanism,
879 pMechanism, 810 pMechanism,
880 mdSession, 811 mdSession,
881 fwSession, 812 fwSession,
882 fwMechanism->mdToken, 813 fwMechanism->mdToken,
883 fwMechanism->fwToken, 814 fwMechanism->fwToken,
884 fwMechanism->mdInstance, 815 fwMechanism->mdInstance,
885 fwMechanism->fwInstance, 816 fwMechanism->fwInstance,
886 pTemplate, 817 pTemplate,
887 ulAttributeCount, 818 ulAttributeCount,
888 pError); 819 pError);
889 820
890 if (!mdObject) { 821 if (!mdObject) {
891 return (NSSCKFWObject *)NULL; 822 return (NSSCKFWObject *)NULL;
892 } 823 }
893 824
894 fwObject = nssCKFWObject_Create(arena, mdObject, 825 fwObject = nssCKFWObject_Create(arena, mdObject,
895 fwSession, fwMechanism->fwToken, fwMechanism->fwInstance, pError); 826 fwSession, fwMechanism->fwToken, fwMechanism ->fwInstance, pError);
896 827
897 return fwObject; 828 return fwObject;
898 } 829 }
899 830
900 /* 831 /*
901 * nssCKFWMechanism_GenerateKeyPair 832 * nssCKFWMechanism_GenerateKeyPair
902 */ 833 */
903 NSS_EXTERN CK_RV 834 NSS_EXTERN CK_RV
904 nssCKFWMechanism_GenerateKeyPair 835 nssCKFWMechanism_GenerateKeyPair(
905 ( 836 NSSCKFWMechanism *fwMechanism,
906 NSSCKFWMechanism *fwMechanism, 837 CK_MECHANISM_PTR pMechanism,
907 CK_MECHANISM_PTR pMechanism, 838 NSSCKFWSession *fwSession,
908 NSSCKFWSession *fwSession, 839 CK_ATTRIBUTE_PTR pPublicKeyTemplate,
909 CK_ATTRIBUTE_PTR pPublicKeyTemplate, 840 CK_ULONG ulPublicKeyAttributeCount,
910 CK_ULONG ulPublicKeyAttributeCount, 841 CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
911 CK_ATTRIBUTE_PTR pPrivateKeyTemplate, 842 CK_ULONG ulPrivateKeyAttributeCount,
912 CK_ULONG ulPrivateKeyAttributeCount, 843 NSSCKFWObject **fwPublicKeyObject,
913 NSSCKFWObject **fwPublicKeyObject, 844 NSSCKFWObject **fwPrivateKeyObject)
914 NSSCKFWObject **fwPrivateKeyObject
915 )
916 { 845 {
917 NSSCKMDSession *mdSession; 846 NSSCKMDSession *mdSession;
918 NSSCKMDObject *mdPublicKeyObject; 847 NSSCKMDObject *mdPublicKeyObject;
919 NSSCKMDObject *mdPrivateKeyObject; 848 NSSCKMDObject *mdPrivateKeyObject;
920 NSSArena *arena; 849 NSSArena *arena;
921 CK_RV error = CKR_OK; 850 CK_RV error = CKR_OK;
922 851
923 if (!fwMechanism->mdMechanism->GenerateKeyPair) { 852 if (!fwMechanism->mdMechanism->GenerateKeyPair) {
924 return CKR_FUNCTION_FAILED; 853 return CKR_FUNCTION_FAILED;
925 } 854 }
926 855
927 arena = nssCKFWToken_GetArena(fwMechanism->fwToken, &error); 856 arena = nssCKFWToken_GetArena(fwMechanism->fwToken, &error);
928 if (!arena) { 857 if (!arena) {
929 if (CKR_OK == error) { 858 if (CKR_OK == error) {
930 error = CKR_GENERAL_ERROR; 859 error = CKR_GENERAL_ERROR;
860 }
861 return error;
931 } 862 }
932 return error;
933 }
934 863
935 mdSession = nssCKFWSession_GetMDSession(fwSession); 864 mdSession = nssCKFWSession_GetMDSession(fwSession);
936 error = fwMechanism->mdMechanism->GenerateKeyPair( 865 error = fwMechanism->mdMechanism->GenerateKeyPair(
937 fwMechanism->mdMechanism, 866 fwMechanism->mdMechanism,
938 fwMechanism, 867 fwMechanism,
939 pMechanism, 868 pMechanism,
940 mdSession, 869 mdSession,
941 fwSession, 870 fwSession,
942 fwMechanism->mdToken, 871 fwMechanism->mdToken,
943 fwMechanism->fwToken, 872 fwMechanism->fwToken,
944 fwMechanism->mdInstance, 873 fwMechanism->mdInstance,
945 fwMechanism->fwInstance, 874 fwMechanism->fwInstance,
946 pPublicKeyTemplate, 875 pPublicKeyTemplate,
947 ulPublicKeyAttributeCount, 876 ulPublicKeyAttributeCount,
948 pPrivateKeyTemplate, 877 pPrivateKeyTemplate,
949 ulPrivateKeyAttributeCount, 878 ulPrivateKeyAttributeCount,
950 &mdPublicKeyObject, 879 &mdPublicKeyObject,
951 &mdPrivateKeyObject); 880 &mdPrivateKeyObject);
952 881
953 if (CKR_OK != error) { 882 if (CKR_OK != error) {
883 return error;
884 }
885
886 *fwPublicKeyObject = nssCKFWObject_Create(arena, mdPublicKeyObject,
887 fwSession, fwMechanism->fwToken, f wMechanism->fwInstance, &error);
888 if (!*fwPublicKeyObject) {
889 return error;
890 }
891 *fwPrivateKeyObject = nssCKFWObject_Create(arena, mdPrivateKeyObject,
892 fwSession, fwMechanism->fwToken, fwMechanism->fwInstance, &error);
893
954 return error; 894 return error;
955 }
956
957 *fwPublicKeyObject = nssCKFWObject_Create(arena, mdPublicKeyObject,
958 fwSession, fwMechanism->fwToken, fwMechanism->fwInstance, &error);
959 if (!*fwPublicKeyObject) {
960 return error;
961 }
962 *fwPrivateKeyObject = nssCKFWObject_Create(arena, mdPrivateKeyObject,
963 fwSession, fwMechanism->fwToken, fwMechanism->fwInstance, &error);
964
965 return error;
966 } 895 }
967 896
968 /* 897 /*
969 * nssCKFWMechanism_GetWrapKeyLength 898 * nssCKFWMechanism_GetWrapKeyLength
970 */ 899 */
971 NSS_EXTERN CK_ULONG 900 NSS_EXTERN CK_ULONG
972 nssCKFWMechanism_GetWrapKeyLength 901 nssCKFWMechanism_GetWrapKeyLength(
973 ( 902 NSSCKFWMechanism *fwMechanism,
974 NSSCKFWMechanism *fwMechanism, 903 CK_MECHANISM_PTR pMechanism,
975 CK_MECHANISM_PTR pMechanism, 904 NSSCKFWSession *fwSession,
976 NSSCKFWSession *fwSession, 905 NSSCKFWObject *fwWrappingKeyObject,
977 NSSCKFWObject *fwWrappingKeyObject, 906 NSSCKFWObject *fwKeyObject,
978 NSSCKFWObject *fwKeyObject, 907 CK_RV *pError)
979 CK_RV *pError
980 )
981 { 908 {
982 NSSCKMDSession *mdSession; 909 NSSCKMDSession *mdSession;
983 NSSCKMDObject *mdWrappingKeyObject; 910 NSSCKMDObject *mdWrappingKeyObject;
984 NSSCKMDObject *mdKeyObject; 911 NSSCKMDObject *mdKeyObject;
985 912
986 if (!fwMechanism->mdMechanism->WrapKey) { 913 if (!fwMechanism->mdMechanism->WrapKey) {
987 *pError = CKR_FUNCTION_FAILED; 914 *pError = CKR_FUNCTION_FAILED;
988 return (CK_ULONG) 0; 915 return (CK_ULONG)0;
989 } 916 }
990 917
991 mdSession = nssCKFWSession_GetMDSession(fwSession); 918 mdSession = nssCKFWSession_GetMDSession(fwSession);
992 mdWrappingKeyObject = nssCKFWObject_GetMDObject(fwWrappingKeyObject); 919 mdWrappingKeyObject = nssCKFWObject_GetMDObject(fwWrappingKeyObject);
993 mdKeyObject = nssCKFWObject_GetMDObject(fwKeyObject); 920 mdKeyObject = nssCKFWObject_GetMDObject(fwKeyObject);
994 return fwMechanism->mdMechanism->GetWrapKeyLength( 921 return fwMechanism->mdMechanism->GetWrapKeyLength(
995 fwMechanism->mdMechanism, 922 fwMechanism->mdMechanism,
996 fwMechanism, 923 fwMechanism,
997 pMechanism, 924 pMechanism,
998 mdSession, 925 mdSession,
999 fwSession, 926 fwSession,
1000 fwMechanism->mdToken, 927 fwMechanism->mdToken,
1001 fwMechanism->fwToken, 928 fwMechanism->fwToken,
1002 fwMechanism->mdInstance, 929 fwMechanism->mdInstance,
1003 fwMechanism->fwInstance, 930 fwMechanism->fwInstance,
1004 mdWrappingKeyObject, 931 mdWrappingKeyObject,
1005 fwWrappingKeyObject, 932 fwWrappingKeyObject,
1006 mdKeyObject, 933 mdKeyObject,
1007 fwKeyObject, 934 fwKeyObject,
1008 pError); 935 pError);
1009 } 936 }
1010 937
1011 /* 938 /*
1012 * nssCKFWMechanism_WrapKey 939 * nssCKFWMechanism_WrapKey
1013 */ 940 */
1014 NSS_EXTERN CK_RV 941 NSS_EXTERN CK_RV
1015 nssCKFWMechanism_WrapKey 942 nssCKFWMechanism_WrapKey(
1016 ( 943 NSSCKFWMechanism *fwMechanism,
1017 NSSCKFWMechanism *fwMechanism, 944 CK_MECHANISM_PTR pMechanism,
1018 CK_MECHANISM_PTR pMechanism, 945 NSSCKFWSession *fwSession,
1019 NSSCKFWSession *fwSession, 946 NSSCKFWObject *fwWrappingKeyObject,
1020 NSSCKFWObject *fwWrappingKeyObject, 947 NSSCKFWObject *fwKeyObject,
1021 NSSCKFWObject *fwKeyObject, 948 NSSItem *wrappedKey)
1022 NSSItem *wrappedKey
1023 )
1024 { 949 {
1025 NSSCKMDSession *mdSession; 950 NSSCKMDSession *mdSession;
1026 NSSCKMDObject *mdWrappingKeyObject; 951 NSSCKMDObject *mdWrappingKeyObject;
1027 NSSCKMDObject *mdKeyObject; 952 NSSCKMDObject *mdKeyObject;
1028 953
1029 if (!fwMechanism->mdMechanism->WrapKey) { 954 if (!fwMechanism->mdMechanism->WrapKey) {
1030 return CKR_FUNCTION_FAILED; 955 return CKR_FUNCTION_FAILED;
1031 } 956 }
1032 957
1033 mdSession = nssCKFWSession_GetMDSession(fwSession); 958 mdSession = nssCKFWSession_GetMDSession(fwSession);
1034 mdWrappingKeyObject = nssCKFWObject_GetMDObject(fwWrappingKeyObject); 959 mdWrappingKeyObject = nssCKFWObject_GetMDObject(fwWrappingKeyObject);
1035 mdKeyObject = nssCKFWObject_GetMDObject(fwKeyObject); 960 mdKeyObject = nssCKFWObject_GetMDObject(fwKeyObject);
1036 return fwMechanism->mdMechanism->WrapKey( 961 return fwMechanism->mdMechanism->WrapKey(
1037 fwMechanism->mdMechanism, 962 fwMechanism->mdMechanism,
1038 fwMechanism, 963 fwMechanism,
1039 pMechanism, 964 pMechanism,
1040 mdSession, 965 mdSession,
1041 fwSession, 966 fwSession,
1042 fwMechanism->mdToken, 967 fwMechanism->mdToken,
1043 fwMechanism->fwToken, 968 fwMechanism->fwToken,
1044 fwMechanism->mdInstance, 969 fwMechanism->mdInstance,
1045 fwMechanism->fwInstance, 970 fwMechanism->fwInstance,
1046 mdWrappingKeyObject, 971 mdWrappingKeyObject,
1047 fwWrappingKeyObject, 972 fwWrappingKeyObject,
1048 mdKeyObject, 973 mdKeyObject,
1049 fwKeyObject, 974 fwKeyObject,
1050 wrappedKey); 975 wrappedKey);
1051 } 976 }
1052 977
1053 /* 978 /*
1054 * nssCKFWMechanism_UnwrapKey 979 * nssCKFWMechanism_UnwrapKey
1055 */ 980 */
1056 NSS_EXTERN NSSCKFWObject * 981 NSS_EXTERN NSSCKFWObject *
1057 nssCKFWMechanism_UnwrapKey 982 nssCKFWMechanism_UnwrapKey(
1058 ( 983 NSSCKFWMechanism *fwMechanism,
1059 NSSCKFWMechanism *fwMechanism, 984 CK_MECHANISM_PTR pMechanism,
1060 CK_MECHANISM_PTR pMechanism, 985 NSSCKFWSession *fwSession,
1061 NSSCKFWSession *fwSession, 986 NSSCKFWObject *fwWrappingKeyObject,
1062 NSSCKFWObject *fwWrappingKeyObject, 987 NSSItem *wrappedKey,
1063 NSSItem *wrappedKey, 988 CK_ATTRIBUTE_PTR pTemplate,
1064 CK_ATTRIBUTE_PTR pTemplate, 989 CK_ULONG ulAttributeCount,
1065 CK_ULONG ulAttributeCount, 990 CK_RV *pError)
1066 CK_RV *pError
1067 )
1068 { 991 {
1069 NSSCKMDSession *mdSession; 992 NSSCKMDSession *mdSession;
1070 NSSCKMDObject *mdObject; 993 NSSCKMDObject *mdObject;
1071 NSSCKMDObject *mdWrappingKeyObject; 994 NSSCKMDObject *mdWrappingKeyObject;
1072 NSSCKFWObject *fwObject = NULL; 995 NSSCKFWObject *fwObject = NULL;
1073 NSSArena *arena; 996 NSSArena *arena;
1074 997
1075 if (!fwMechanism->mdMechanism->UnwrapKey) { 998 if (!fwMechanism->mdMechanism->UnwrapKey) {
1076 /* we could simulate UnwrapKey using Decrypt and Create object, but 999 /* we could simulate UnwrapKey using Decrypt and Create object, but
1077 * 1) it's not clear that would work well, and 2) the low level token 1000 * 1) it's not clear that would work well, and 2) the low level token
1078 * may want to restrict unwrap key for a reason, so just fail it it 1001 * may want to restrict unwrap key for a reason, so just fail it it
1079 * can't be done */ 1002 * can't be done */
1080 *pError = CKR_FUNCTION_FAILED; 1003 *pError = CKR_FUNCTION_FAILED;
1081 return (NSSCKFWObject *)NULL; 1004 return (NSSCKFWObject *)NULL;
1082 } 1005 }
1083 1006
1084 arena = nssCKFWToken_GetArena(fwMechanism->fwToken, pError); 1007 arena = nssCKFWToken_GetArena(fwMechanism->fwToken, pError);
1085 if (!arena) { 1008 if (!arena) {
1086 if (CKR_OK == *pError) { 1009 if (CKR_OK == *pError) {
1087 *pError = CKR_GENERAL_ERROR; 1010 *pError = CKR_GENERAL_ERROR;
1011 }
1012 return (NSSCKFWObject *)NULL;
1088 } 1013 }
1089 return (NSSCKFWObject *)NULL;
1090 }
1091 1014
1092 mdSession = nssCKFWSession_GetMDSession(fwSession); 1015 mdSession = nssCKFWSession_GetMDSession(fwSession);
1093 mdWrappingKeyObject = nssCKFWObject_GetMDObject(fwWrappingKeyObject); 1016 mdWrappingKeyObject = nssCKFWObject_GetMDObject(fwWrappingKeyObject);
1094 mdObject = fwMechanism->mdMechanism->UnwrapKey( 1017 mdObject = fwMechanism->mdMechanism->UnwrapKey(
1095 fwMechanism->mdMechanism, 1018 fwMechanism->mdMechanism,
1096 fwMechanism, 1019 fwMechanism,
1097 pMechanism, 1020 pMechanism,
1098 mdSession, 1021 mdSession,
1099 fwSession, 1022 fwSession,
1100 fwMechanism->mdToken, 1023 fwMechanism->mdToken,
1101 fwMechanism->fwToken, 1024 fwMechanism->fwToken,
1102 fwMechanism->mdInstance, 1025 fwMechanism->mdInstance,
1103 fwMechanism->fwInstance, 1026 fwMechanism->fwInstance,
1104 mdWrappingKeyObject, 1027 mdWrappingKeyObject,
1105 fwWrappingKeyObject, 1028 fwWrappingKeyObject,
1106 wrappedKey, 1029 wrappedKey,
1107 pTemplate, 1030 pTemplate,
1108 ulAttributeCount, 1031 ulAttributeCount,
1109 pError); 1032 pError);
1110 1033
1111 if (!mdObject) { 1034 if (!mdObject) {
1112 return (NSSCKFWObject *)NULL; 1035 return (NSSCKFWObject *)NULL;
1113 } 1036 }
1114 1037
1115 fwObject = nssCKFWObject_Create(arena, mdObject, 1038 fwObject = nssCKFWObject_Create(arena, mdObject,
1116 fwSession, fwMechanism->fwToken, fwMechanism->fwInstance, pError); 1039 fwSession, fwMechanism->fwToken, fwMechanism ->fwInstance, pError);
1117 1040
1118 return fwObject; 1041 return fwObject;
1119 } 1042 }
1120 1043
1121 /* 1044 /*
1122 * nssCKFWMechanism_DeriveKey 1045 * nssCKFWMechanism_DeriveKey
1123 */ 1046 */
1124 NSS_EXTERN NSSCKFWObject * 1047 NSS_EXTERN NSSCKFWObject *
1125 nssCKFWMechanism_DeriveKey 1048 nssCKFWMechanism_DeriveKey(
1126 ( 1049 NSSCKFWMechanism *fwMechanism,
1127 NSSCKFWMechanism *fwMechanism, 1050 CK_MECHANISM_PTR pMechanism,
1128 CK_MECHANISM_PTR pMechanism, 1051 NSSCKFWSession *fwSession,
1129 NSSCKFWSession *fwSession, 1052 NSSCKFWObject *fwBaseKeyObject,
1130 NSSCKFWObject *fwBaseKeyObject, 1053 CK_ATTRIBUTE_PTR pTemplate,
1131 CK_ATTRIBUTE_PTR pTemplate, 1054 CK_ULONG ulAttributeCount,
1132 CK_ULONG ulAttributeCount, 1055 CK_RV *pError)
1133 CK_RV *pError
1134 )
1135 { 1056 {
1136 NSSCKMDSession *mdSession; 1057 NSSCKMDSession *mdSession;
1137 NSSCKMDObject *mdObject; 1058 NSSCKMDObject *mdObject;
1138 NSSCKMDObject *mdBaseKeyObject; 1059 NSSCKMDObject *mdBaseKeyObject;
1139 NSSCKFWObject *fwObject = NULL; 1060 NSSCKFWObject *fwObject = NULL;
1140 NSSArena *arena; 1061 NSSArena *arena;
1141 1062
1142 if (!fwMechanism->mdMechanism->DeriveKey) { 1063 if (!fwMechanism->mdMechanism->DeriveKey) {
1143 *pError = CKR_FUNCTION_FAILED; 1064 *pError = CKR_FUNCTION_FAILED;
1144 return (NSSCKFWObject *)NULL; 1065 return (NSSCKFWObject *)NULL;
1145 } 1066 }
1146 1067
1147 arena = nssCKFWToken_GetArena(fwMechanism->fwToken, pError); 1068 arena = nssCKFWToken_GetArena(fwMechanism->fwToken, pError);
1148 if (!arena) { 1069 if (!arena) {
1149 if (CKR_OK == *pError) { 1070 if (CKR_OK == *pError) {
1150 *pError = CKR_GENERAL_ERROR; 1071 *pError = CKR_GENERAL_ERROR;
1072 }
1073 return (NSSCKFWObject *)NULL;
1151 } 1074 }
1152 return (NSSCKFWObject *)NULL;
1153 }
1154 1075
1155 mdSession = nssCKFWSession_GetMDSession(fwSession); 1076 mdSession = nssCKFWSession_GetMDSession(fwSession);
1156 mdBaseKeyObject = nssCKFWObject_GetMDObject(fwBaseKeyObject); 1077 mdBaseKeyObject = nssCKFWObject_GetMDObject(fwBaseKeyObject);
1157 mdObject = fwMechanism->mdMechanism->DeriveKey( 1078 mdObject = fwMechanism->mdMechanism->DeriveKey(
1158 fwMechanism->mdMechanism, 1079 fwMechanism->mdMechanism,
1159 fwMechanism, 1080 fwMechanism,
1160 pMechanism, 1081 pMechanism,
1161 mdSession, 1082 mdSession,
1162 fwSession, 1083 fwSession,
1163 fwMechanism->mdToken, 1084 fwMechanism->mdToken,
1164 fwMechanism->fwToken, 1085 fwMechanism->fwToken,
1165 fwMechanism->mdInstance, 1086 fwMechanism->mdInstance,
1166 fwMechanism->fwInstance, 1087 fwMechanism->fwInstance,
1167 mdBaseKeyObject, 1088 mdBaseKeyObject,
1168 fwBaseKeyObject, 1089 fwBaseKeyObject,
1169 pTemplate, 1090 pTemplate,
1170 ulAttributeCount, 1091 ulAttributeCount,
1171 pError); 1092 pError);
1172 1093
1173 if (!mdObject) { 1094 if (!mdObject) {
1174 return (NSSCKFWObject *)NULL; 1095 return (NSSCKFWObject *)NULL;
1175 } 1096 }
1176 1097
1177 fwObject = nssCKFWObject_Create(arena, mdObject, 1098 fwObject = nssCKFWObject_Create(arena, mdObject,
1178 fwSession, fwMechanism->fwToken, fwMechanism->fwInstance, pError); 1099 fwSession, fwMechanism->fwToken, fwMechanism ->fwInstance, pError);
1179 1100
1180 return fwObject; 1101 return fwObject;
1181 } 1102 }
1182
OLDNEW
« no previous file with comments | « nss/lib/ckfw/instance.c ('k') | nss/lib/ckfw/mutex.c » ('j') | nss/lib/util/secoid.c » ('J')

Powered by Google App Engine
This is Rietveld 408576698