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
3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4 
5 #ifndef CKFW_H
6 #define CKFW_H
7 
8 /*
9  * ckfw.h
10  *
11  * This file prototypes the private calls of the NSS Cryptoki Framework.
12  */
13 
14 #ifndef NSSBASET_H
15 #include "nssbaset.h"
16 #endif /* NSSBASET_H */
17 
18 #ifndef NSSCKT_H
19 #include "nssckt.h"
20 #endif /* NSSCKT_H */
21 
22 #ifndef NSSCKFWT_H
23 #include "nssckfwt.h"
24 #endif /* NSSCKFWT_H */
25 
26 #ifndef NSSCKMDT_H
27 #include "nssckmdt.h"
28 #endif /* NSSCKMDT_H */
29 
30 /*
31  * NSSCKFWInstance
32  *
33  *  -- create/destroy --
34  *  nssCKFWInstance_Create
35  *  nssCKFWInstance_Destroy
36  *
37  *  -- implement public accessors --
38  *  nssCKFWInstance_GetMDInstance
39  *  nssCKFWInstance_GetArena
40  *  nssCKFWInstance_MayCreatePthreads
41  *  nssCKFWInstance_CreateMutex
42  *  nssCKFWInstance_GetConfigurationData
43  *  nssCKFWInstance_GetInitArgs
44  *
45  *  -- private accessors --
46  *  nssCKFWInstance_CreateSessionHandle
47  *  nssCKFWInstance_ResolveSessionHandle
48  *  nssCKFWInstance_DestroySessionHandle
49  *  nssCKFWInstance_FindSessionHandle
50  *  nssCKFWInstance_CreateObjectHandle
51  *  nssCKFWInstance_ResolveObjectHandle
52  *  nssCKFWInstance_DestroyObjectHandle
53  *  nssCKFWInstance_FindObjectHandle
54  *
55  *  -- module fronts --
56  *  nssCKFWInstance_GetNSlots
57  *  nssCKFWInstance_GetCryptokiVersion
58  *  nssCKFWInstance_GetManufacturerID
59  *  nssCKFWInstance_GetFlags
60  *  nssCKFWInstance_GetLibraryDescription
61  *  nssCKFWInstance_GetLibraryVersion
62  *  nssCKFWInstance_GetModuleHandlesSessionObjects
63  *  nssCKFWInstance_GetSlots
64  *  nssCKFWInstance_WaitForSlotEvent
65  *
66  *  -- debugging versions only --
67  *  nssCKFWInstance_verifyPointer
68  */
69 
70 /*
71  * nssCKFWInstance_Create
72  *
73  */
74 NSS_EXTERN NSSCKFWInstance *
75 nssCKFWInstance_Create(
76     CK_C_INITIALIZE_ARGS_PTR pInitArgs,
77     CryptokiLockingState LockingState,
78     NSSCKMDInstance *mdInstance,
79     CK_RV *pError);
80 
81 /*
82  * nssCKFWInstance_Destroy
83  *
84  */
85 NSS_EXTERN CK_RV
86 nssCKFWInstance_Destroy(
87     NSSCKFWInstance *fwInstance);
88 
89 /*
90  * nssCKFWInstance_GetMDInstance
91  *
92  */
93 NSS_EXTERN NSSCKMDInstance *
94 nssCKFWInstance_GetMDInstance(
95     NSSCKFWInstance *fwInstance);
96 
97 /*
98  * nssCKFWInstance_GetArena
99  *
100  */
101 NSS_EXTERN NSSArena *
102 nssCKFWInstance_GetArena(
103     NSSCKFWInstance *fwInstance,
104     CK_RV *pError);
105 
106 /*
107  * nssCKFWInstance_MayCreatePthreads
108  *
109  */
110 NSS_EXTERN CK_BBOOL
111 nssCKFWInstance_MayCreatePthreads(
112     NSSCKFWInstance *fwInstance);
113 
114 /*
115  * nssCKFWInstance_CreateMutex
116  *
117  */
118 NSS_EXTERN NSSCKFWMutex *
119 nssCKFWInstance_CreateMutex(
120     NSSCKFWInstance *fwInstance,
121     NSSArena *arena,
122     CK_RV *pError);
123 
124 /*
125  * nssCKFWInstance_GetConfigurationData
126  *
127  */
128 NSS_EXTERN NSSUTF8 *
129 nssCKFWInstance_GetConfigurationData(
130     NSSCKFWInstance *fwInstance);
131 
132 /*
133  * nssCKFWInstance_GetInitArgs
134  *
135  */
136 NSS_EXTERN CK_C_INITIALIZE_ARGS_PTR
137 nssCKFWInstance_GetInitArgs(
138     NSSCKFWInstance *fwInstance);
139 
140 /*
141  * nssCKFWInstance_CreateSessionHandle
142  *
143  */
144 NSS_EXTERN CK_SESSION_HANDLE
145 nssCKFWInstance_CreateSessionHandle(
146     NSSCKFWInstance *fwInstance,
147     NSSCKFWSession *fwSession,
148     CK_RV *pError);
149 
150 /*
151  * nssCKFWInstance_ResolveSessionHandle
152  *
153  */
154 NSS_EXTERN NSSCKFWSession *
155 nssCKFWInstance_ResolveSessionHandle(
156     NSSCKFWInstance *fwInstance,
157     CK_SESSION_HANDLE hSession);
158 
159 /*
160  * nssCKFWInstance_DestroySessionHandle
161  *
162  */
163 NSS_EXTERN void
164 nssCKFWInstance_DestroySessionHandle(
165     NSSCKFWInstance *fwInstance,
166     CK_SESSION_HANDLE hSession);
167 
168 /*
169  * nssCKFWInstance_FindSessionHandle
170  *
171  */
172 NSS_EXTERN CK_SESSION_HANDLE
173 nssCKFWInstance_FindSessionHandle(
174     NSSCKFWInstance *fwInstance,
175     NSSCKFWSession *fwSession);
176 
177 /*
178  * nssCKFWInstance_CreateObjectHandle
179  *
180  */
181 NSS_EXTERN CK_OBJECT_HANDLE
182 nssCKFWInstance_CreateObjectHandle(
183     NSSCKFWInstance *fwInstance,
184     NSSCKFWObject *fwObject,
185     CK_RV *pError);
186 
187 /*
188  * nssCKFWInstance_ResolveObjectHandle
189  *
190  */
191 NSS_EXTERN NSSCKFWObject *
192 nssCKFWInstance_ResolveObjectHandle(
193     NSSCKFWInstance *fwInstance,
194     CK_OBJECT_HANDLE hObject);
195 
196 /*
197  * nssCKFWInstance_ReassignObjectHandle
198  *
199  */
200 NSS_EXTERN CK_RV
201 nssCKFWInstance_ReassignObjectHandle(
202     NSSCKFWInstance *fwInstance,
203     CK_OBJECT_HANDLE hObject,
204     NSSCKFWObject *fwObject);
205 
206 /*
207  * nssCKFWInstance_DestroyObjectHandle
208  *
209  */
210 NSS_EXTERN void
211 nssCKFWInstance_DestroyObjectHandle(
212     NSSCKFWInstance *fwInstance,
213     CK_OBJECT_HANDLE hObject);
214 
215 /*
216  * nssCKFWInstance_FindObjectHandle
217  *
218  */
219 NSS_EXTERN CK_OBJECT_HANDLE
220 nssCKFWInstance_FindObjectHandle(
221     NSSCKFWInstance *fwInstance,
222     NSSCKFWObject *fwObject);
223 
224 /*
225  * nssCKFWInstance_GetNSlots
226  *
227  */
228 NSS_EXTERN CK_ULONG
229 nssCKFWInstance_GetNSlots(
230     NSSCKFWInstance *fwInstance,
231     CK_RV *pError);
232 
233 /*
234  * nssCKFWInstance_GetCryptokiVersion
235  *
236  */
237 NSS_EXTERN CK_VERSION
238 nssCKFWInstance_GetCryptokiVersion(
239     NSSCKFWInstance *fwInstance);
240 
241 /*
242  * nssCKFWInstance_GetManufacturerID
243  *
244  */
245 NSS_EXTERN CK_RV
246 nssCKFWInstance_GetManufacturerID(
247     NSSCKFWInstance *fwInstance,
248     CK_CHAR manufacturerID[32]);
249 
250 /*
251  * nssCKFWInstance_GetFlags
252  *
253  */
254 NSS_EXTERN CK_ULONG
255 nssCKFWInstance_GetFlags(
256     NSSCKFWInstance *fwInstance);
257 
258 /*
259  * nssCKFWInstance_GetLibraryDescription
260  *
261  */
262 NSS_EXTERN CK_RV
263 nssCKFWInstance_GetLibraryDescription(
264     NSSCKFWInstance *fwInstance,
265     CK_CHAR libraryDescription[32]);
266 
267 /*
268  * nssCKFWInstance_GetLibraryVersion
269  *
270  */
271 NSS_EXTERN CK_VERSION
272 nssCKFWInstance_GetLibraryVersion(
273     NSSCKFWInstance *fwInstance);
274 
275 /*
276  * nssCKFWInstance_GetModuleHandlesSessionObjects
277  *
278  */
279 NSS_EXTERN CK_BBOOL
280 nssCKFWInstance_GetModuleHandlesSessionObjects(
281     NSSCKFWInstance *fwInstance);
282 
283 /*
284  * nssCKFWInstance_GetSlots
285  *
286  */
287 NSS_EXTERN NSSCKFWSlot **
288 nssCKFWInstance_GetSlots(
289     NSSCKFWInstance *fwInstance,
290     CK_RV *pError);
291 
292 /*
293  * nssCKFWInstance_WaitForSlotEvent
294  *
295  */
296 NSS_EXTERN NSSCKFWSlot *
297 nssCKFWInstance_WaitForSlotEvent(
298     NSSCKFWInstance *fwInstance,
299     CK_BBOOL block,
300     CK_RV *pError);
301 
302 /*
303  * nssCKFWInstance_verifyPointer
304  *
305  */
306 NSS_EXTERN CK_RV
307 nssCKFWInstance_verifyPointer(
308     const NSSCKFWInstance *fwInstance);
309 
310 /*
311  * NSSCKFWSlot
312  *
313  *  -- create/destroy --
314  *  nssCKFWSlot_Create
315  *  nssCKFWSlot_Destroy
316  *
317  *  -- implement public accessors --
318  *  nssCKFWSlot_GetMDSlot
319  *  nssCKFWSlot_GetFWInstance
320  *  nssCKFWSlot_GetMDInstance
321  *
322  *  -- private accessors --
323  *  nssCKFWSlot_GetSlotID
324  *
325  *  -- module fronts --
326  *  nssCKFWSlot_GetSlotDescription
327  *  nssCKFWSlot_GetManufacturerID
328  *  nssCKFWSlot_GetTokenPresent
329  *  nssCKFWSlot_GetRemovableDevice
330  *  nssCKFWSlot_GetHardwareSlot
331  *  nssCKFWSlot_GetHardwareVersion
332  *  nssCKFWSlot_GetFirmwareVersion
333  *  nssCKFWSlot_GetToken
334  */
335 
336 /*
337  * nssCKFWSlot_Create
338  *
339  */
340 NSS_EXTERN NSSCKFWSlot *
341 nssCKFWSlot_Create(
342     NSSCKFWInstance *fwInstance,
343     NSSCKMDSlot *mdSlot,
344     CK_SLOT_ID slotID,
345     CK_RV *pError);
346 
347 /*
348  * nssCKFWSlot_Destroy
349  *
350  */
351 NSS_EXTERN CK_RV
352 nssCKFWSlot_Destroy(
353     NSSCKFWSlot *fwSlot);
354 
355 /*
356  * nssCKFWSlot_GetMDSlot
357  *
358  */
359 NSS_EXTERN NSSCKMDSlot *
360 nssCKFWSlot_GetMDSlot(
361     NSSCKFWSlot *fwSlot);
362 
363 /*
364  * nssCKFWSlot_GetFWInstance
365  *
366  */
367 
368 NSS_EXTERN NSSCKFWInstance *
369 nssCKFWSlot_GetFWInstance(
370     NSSCKFWSlot *fwSlot);
371 
372 /*
373  * nssCKFWSlot_GetMDInstance
374  *
375  */
376 
377 NSS_EXTERN NSSCKMDInstance *
378 nssCKFWSlot_GetMDInstance(
379     NSSCKFWSlot *fwSlot);
380 
381 /*
382  * nssCKFWSlot_GetSlotID
383  *
384  */
385 NSS_EXTERN CK_SLOT_ID
386 nssCKFWSlot_GetSlotID(
387     NSSCKFWSlot *fwSlot);
388 
389 /*
390  * nssCKFWSlot_GetSlotDescription
391  *
392  */
393 NSS_EXTERN CK_RV
394 nssCKFWSlot_GetSlotDescription(
395     NSSCKFWSlot *fwSlot,
396     CK_CHAR slotDescription[64]);
397 
398 /*
399  * nssCKFWSlot_GetManufacturerID
400  *
401  */
402 NSS_EXTERN CK_RV
403 nssCKFWSlot_GetManufacturerID(
404     NSSCKFWSlot *fwSlot,
405     CK_CHAR manufacturerID[32]);
406 
407 /*
408  * nssCKFWSlot_GetTokenPresent
409  *
410  */
411 NSS_EXTERN CK_BBOOL
412 nssCKFWSlot_GetTokenPresent(
413     NSSCKFWSlot *fwSlot);
414 
415 /*
416  * nssCKFWSlot_GetRemovableDevice
417  *
418  */
419 NSS_EXTERN CK_BBOOL
420 nssCKFWSlot_GetRemovableDevice(
421     NSSCKFWSlot *fwSlot);
422 
423 /*
424  * nssCKFWSlot_GetHardwareSlot
425  *
426  */
427 NSS_EXTERN CK_BBOOL
428 nssCKFWSlot_GetHardwareSlot(
429     NSSCKFWSlot *fwSlot);
430 
431 /*
432  * nssCKFWSlot_GetHardwareVersion
433  *
434  */
435 NSS_EXTERN CK_VERSION
436 nssCKFWSlot_GetHardwareVersion(
437     NSSCKFWSlot *fwSlot);
438 
439 /*
440  * nssCKFWSlot_GetFirmwareVersion
441  *
442  */
443 NSS_EXTERN CK_VERSION
444 nssCKFWSlot_GetFirmwareVersion(
445     NSSCKFWSlot *fwSlot);
446 
447 /*
448  * nssCKFWSlot_GetToken
449  *
450  */
451 NSS_EXTERN NSSCKFWToken *
452 nssCKFWSlot_GetToken(
453     NSSCKFWSlot *fwSlot,
454     CK_RV *pError);
455 
456 /*
457  * nssCKFWSlot_ClearToken
458  *
459  */
460 NSS_EXTERN void
461 nssCKFWSlot_ClearToken(
462     NSSCKFWSlot *fwSlot);
463 
464 /*
465  * NSSCKFWToken
466  *
467  *  -- create/destroy --
468  *  nssCKFWToken_Create
469  *  nssCKFWToken_Destroy
470  *
471  *  -- implement public accessors --
472  *  nssCKFWToken_GetMDToken
473  *  nssCKFWToken_GetFWSlot
474  *  nssCKFWToken_GetMDSlot
475  *  nssCKFWToken_GetSessionState
476  *
477  *  -- private accessors --
478  *  nssCKFWToken_SetSessionState
479  *  nssCKFWToken_RemoveSession
480  *  nssCKFWToken_CloseAllSessions
481  *  nssCKFWToken_GetSessionCount
482  *  nssCKFWToken_GetRwSessionCount
483  *  nssCKFWToken_GetRoSessionCount
484  *  nssCKFWToken_GetSessionObjectHash
485  *  nssCKFWToken_GetMDObjectHash
486  *  nssCKFWToken_GetObjectHandleHash
487  *
488  *  -- module fronts --
489  *  nssCKFWToken_InitToken
490  *  nssCKFWToken_GetLabel
491  *  nssCKFWToken_GetManufacturerID
492  *  nssCKFWToken_GetModel
493  *  nssCKFWToken_GetSerialNumber
494  *  nssCKFWToken_GetHasRNG
495  *  nssCKFWToken_GetIsWriteProtected
496  *  nssCKFWToken_GetLoginRequired
497  *  nssCKFWToken_GetUserPinInitialized
498  *  nssCKFWToken_GetRestoreKeyNotNeeded
499  *  nssCKFWToken_GetHasClockOnToken
500  *  nssCKFWToken_GetHasProtectedAuthenticationPath
501  *  nssCKFWToken_GetSupportsDualCryptoOperations
502  *  nssCKFWToken_GetMaxSessionCount
503  *  nssCKFWToken_GetMaxRwSessionCount
504  *  nssCKFWToken_GetMaxPinLen
505  *  nssCKFWToken_GetMinPinLen
506  *  nssCKFWToken_GetTotalPublicMemory
507  *  nssCKFWToken_GetFreePublicMemory
508  *  nssCKFWToken_GetTotalPrivateMemory
509  *  nssCKFWToken_GetFreePrivateMemory
510  *  nssCKFWToken_GetHardwareVersion
511  *  nssCKFWToken_GetFirmwareVersion
512  *  nssCKFWToken_GetUTCTime
513  *  nssCKFWToken_OpenSession
514  *  nssCKFWToken_GetMechanismCount
515  *  nssCKFWToken_GetMechanismTypes
516  *  nssCKFWToken_GetMechanism
517  */
518 
519 /*
520  * nssCKFWToken_Create
521  *
522  */
523 NSS_EXTERN NSSCKFWToken *
524 nssCKFWToken_Create(
525     NSSCKFWSlot *fwSlot,
526     NSSCKMDToken *mdToken,
527     CK_RV *pError);
528 
529 /*
530  * nssCKFWToken_Destroy
531  *
532  */
533 NSS_EXTERN CK_RV
534 nssCKFWToken_Destroy(
535     NSSCKFWToken *fwToken);
536 
537 /*
538  * nssCKFWToken_GetMDToken
539  *
540  */
541 NSS_EXTERN NSSCKMDToken *
542 nssCKFWToken_GetMDToken(
543     NSSCKFWToken *fwToken);
544 
545 /*
546  * nssCKFWToken_GetArena
547  *
548  */
549 NSS_EXTERN NSSArena *
550 nssCKFWToken_GetArena(
551     NSSCKFWToken *fwToken,
552     CK_RV *pError);
553 
554 /*
555  * nssCKFWToken_GetFWSlot
556  *
557  */
558 NSS_EXTERN NSSCKFWSlot *
559 nssCKFWToken_GetFWSlot(
560     NSSCKFWToken *fwToken);
561 
562 /*
563  * nssCKFWToken_GetMDSlot
564  *
565  */
566 NSS_EXTERN NSSCKMDSlot *
567 nssCKFWToken_GetMDSlot(
568     NSSCKFWToken *fwToken);
569 
570 /*
571  * nssCKFWToken_GetSessionState
572  *
573  */
574 NSS_EXTERN CK_STATE
575 nssCKFWToken_GetSessionState(
576     NSSCKFWToken *fwToken);
577 
578 /*
579  * nssCKFWToken_InitToken
580  *
581  */
582 NSS_EXTERN CK_RV
583 nssCKFWToken_InitToken(
584     NSSCKFWToken *fwToken,
585     NSSItem *pin,
586     NSSUTF8 *label);
587 
588 /*
589  * nssCKFWToken_GetLabel
590  *
591  */
592 NSS_EXTERN CK_RV
593 nssCKFWToken_GetLabel(
594     NSSCKFWToken *fwToken,
595     CK_CHAR label[32]);
596 
597 /*
598  * nssCKFWToken_GetManufacturerID
599  *
600  */
601 NSS_EXTERN CK_RV
602 nssCKFWToken_GetManufacturerID(
603     NSSCKFWToken *fwToken,
604     CK_CHAR manufacturerID[32]);
605 
606 /*
607  * nssCKFWToken_GetModel
608  *
609  */
610 NSS_EXTERN CK_RV
611 nssCKFWToken_GetModel(
612     NSSCKFWToken *fwToken,
613     CK_CHAR model[16]);
614 
615 /*
616  * nssCKFWToken_GetSerialNumber
617  *
618  */
619 NSS_EXTERN CK_RV
620 nssCKFWToken_GetSerialNumber(
621     NSSCKFWToken *fwToken,
622     CK_CHAR serialNumber[16]);
623 
624 /*
625  * nssCKFWToken_GetHasRNG
626  *
627  */
628 NSS_EXTERN CK_BBOOL
629 nssCKFWToken_GetHasRNG(
630     NSSCKFWToken *fwToken);
631 
632 /*
633  * nssCKFWToken_GetIsWriteProtected
634  *
635  */
636 NSS_EXTERN CK_BBOOL
637 nssCKFWToken_GetIsWriteProtected(
638     NSSCKFWToken *fwToken);
639 
640 /*
641  * nssCKFWToken_GetLoginRequired
642  *
643  */
644 NSS_EXTERN CK_BBOOL
645 nssCKFWToken_GetLoginRequired(
646     NSSCKFWToken *fwToken);
647 
648 /*
649  * nssCKFWToken_GetUserPinInitialized
650  *
651  */
652 NSS_EXTERN CK_BBOOL
653 nssCKFWToken_GetUserPinInitialized(
654     NSSCKFWToken *fwToken);
655 
656 /*
657  * nssCKFWToken_GetRestoreKeyNotNeeded
658  *
659  */
660 NSS_EXTERN CK_BBOOL
661 nssCKFWToken_GetRestoreKeyNotNeeded(
662     NSSCKFWToken *fwToken);
663 
664 /*
665  * nssCKFWToken_GetHasClockOnToken
666  *
667  */
668 NSS_EXTERN CK_BBOOL
669 nssCKFWToken_GetHasClockOnToken(
670     NSSCKFWToken *fwToken);
671 
672 /*
673  * nssCKFWToken_GetHasProtectedAuthenticationPath
674  *
675  */
676 NSS_EXTERN CK_BBOOL
677 nssCKFWToken_GetHasProtectedAuthenticationPath(
678     NSSCKFWToken *fwToken);
679 
680 /*
681  * nssCKFWToken_GetSupportsDualCryptoOperations
682  *
683  */
684 NSS_EXTERN CK_BBOOL
685 nssCKFWToken_GetSupportsDualCryptoOperations(
686     NSSCKFWToken *fwToken);
687 
688 /*
689  * nssCKFWToken_GetMaxSessionCount
690  *
691  */
692 NSS_EXTERN CK_ULONG
693 nssCKFWToken_GetMaxSessionCount(
694     NSSCKFWToken *fwToken);
695 
696 /*
697  * nssCKFWToken_GetMaxRwSessionCount
698  *
699  */
700 NSS_EXTERN CK_ULONG
701 nssCKFWToken_GetMaxRwSessionCount(
702     NSSCKFWToken *fwToken);
703 
704 /*
705  * nssCKFWToken_GetMaxPinLen
706  *
707  */
708 NSS_EXTERN CK_ULONG
709 nssCKFWToken_GetMaxPinLen(
710     NSSCKFWToken *fwToken);
711 
712 /*
713  * nssCKFWToken_GetMinPinLen
714  *
715  */
716 NSS_EXTERN CK_ULONG
717 nssCKFWToken_GetMinPinLen(
718     NSSCKFWToken *fwToken);
719 
720 /*
721  * nssCKFWToken_GetTotalPublicMemory
722  *
723  */
724 NSS_EXTERN CK_ULONG
725 nssCKFWToken_GetTotalPublicMemory(
726     NSSCKFWToken *fwToken);
727 
728 /*
729  * nssCKFWToken_GetFreePublicMemory
730  *
731  */
732 NSS_EXTERN CK_ULONG
733 nssCKFWToken_GetFreePublicMemory(
734     NSSCKFWToken *fwToken);
735 
736 /*
737  * nssCKFWToken_GetTotalPrivateMemory
738  *
739  */
740 NSS_EXTERN CK_ULONG
741 nssCKFWToken_GetTotalPrivateMemory(
742     NSSCKFWToken *fwToken);
743 
744 /*
745  * nssCKFWToken_GetFreePrivateMemory
746  *
747  */
748 NSS_EXTERN CK_ULONG
749 nssCKFWToken_GetFreePrivateMemory(
750     NSSCKFWToken *fwToken);
751 
752 /*
753  * nssCKFWToken_GetHardwareVersion
754  *
755  */
756 NSS_EXTERN CK_VERSION
757 nssCKFWToken_GetHardwareVersion(
758     NSSCKFWToken *fwToken);
759 
760 /*
761  * nssCKFWToken_GetFirmwareVersion
762  *
763  */
764 NSS_EXTERN CK_VERSION
765 nssCKFWToken_GetFirmwareVersion(
766     NSSCKFWToken *fwToken);
767 
768 /*
769  * nssCKFWToken_GetUTCTime
770  *
771  */
772 NSS_EXTERN CK_RV
773 nssCKFWToken_GetUTCTime(
774     NSSCKFWToken *fwToken,
775     CK_CHAR utcTime[16]);
776 
777 /*
778  * nssCKFWToken_OpenSession
779  *
780  */
781 NSS_EXTERN NSSCKFWSession *
782 nssCKFWToken_OpenSession(
783     NSSCKFWToken *fwToken,
784     CK_BBOOL rw,
785     CK_VOID_PTR pApplication,
786     CK_NOTIFY Notify,
787     CK_RV *pError);
788 
789 /*
790  * nssCKFWToken_GetMechanismCount
791  *
792  */
793 NSS_EXTERN CK_ULONG
794 nssCKFWToken_GetMechanismCount(
795     NSSCKFWToken *fwToken);
796 
797 /*
798  * nssCKFWToken_GetMechanismTypes
799  *
800  */
801 NSS_EXTERN CK_RV
802 nssCKFWToken_GetMechanismTypes(
803     NSSCKFWToken *fwToken,
804     CK_MECHANISM_TYPE types[]);
805 
806 /*
807  * nssCKFWToken_GetMechanism
808  *
809  */
810 NSS_EXTERN NSSCKFWMechanism *
811 nssCKFWToken_GetMechanism(
812     NSSCKFWToken *fwToken,
813     CK_MECHANISM_TYPE which,
814     CK_RV *pError);
815 
816 /*
817  * nssCKFWToken_SetSessionState
818  *
819  */
820 NSS_EXTERN CK_RV
821 nssCKFWToken_SetSessionState(
822     NSSCKFWToken *fwToken,
823     CK_STATE newState);
824 
825 /*
826  * nssCKFWToken_RemoveSession
827  *
828  */
829 NSS_EXTERN CK_RV
830 nssCKFWToken_RemoveSession(
831     NSSCKFWToken *fwToken,
832     NSSCKFWSession *fwSession);
833 
834 /*
835  * nssCKFWToken_CloseAllSessions
836  *
837  */
838 NSS_EXTERN CK_RV
839 nssCKFWToken_CloseAllSessions(
840     NSSCKFWToken *fwToken);
841 
842 /*
843  * nssCKFWToken_GetSessionCount
844  *
845  */
846 NSS_EXTERN CK_ULONG
847 nssCKFWToken_GetSessionCount(
848     NSSCKFWToken *fwToken);
849 
850 /*
851  * nssCKFWToken_GetRwSessionCount
852  *
853  */
854 NSS_EXTERN CK_ULONG
855 nssCKFWToken_GetRwSessionCount(
856     NSSCKFWToken *fwToken);
857 
858 /*
859  * nssCKFWToken_GetRoSessionCount
860  *
861  */
862 NSS_EXTERN CK_ULONG
863 nssCKFWToken_GetRoSessionCount(
864     NSSCKFWToken *fwToken);
865 
866 /*
867  * nssCKFWToken_GetSessionObjectHash
868  *
869  */
870 NSS_EXTERN nssCKFWHash *
871 nssCKFWToken_GetSessionObjectHash(
872     NSSCKFWToken *fwToken);
873 
874 /*
875  * nssCKFWToken_GetMDObjectHash
876  *
877  */
878 NSS_EXTERN nssCKFWHash *
879 nssCKFWToken_GetMDObjectHash(
880     NSSCKFWToken *fwToken);
881 
882 /*
883  * nssCKFWToken_GetObjectHandleHash
884  *
885  */
886 NSS_EXTERN nssCKFWHash *
887 nssCKFWToken_GetObjectHandleHash(
888     NSSCKFWToken *fwToken);
889 
890 /*
891  * NSSCKFWMechanism
892  *
893  *  -- create/destroy --
894  *  nssCKFWMechanism_Create
895  *  nssCKFWMechanism_Destroy
896  *
897  *  -- implement public accessors --
898  *  nssCKFWMechanism_GetMDMechanism
899  *
900  *  -- private accessors --
901  *
902  *  -- module fronts --
903  *  nssCKFWMechanism_GetMinKeySize
904  *  nssCKFWMechanism_GetMaxKeySize
905  *  nssCKFWMechanism_GetInHardware
906  *  nssCKFWMechanism_GetCanEncrypt
907  *  nssCKFWMechanism_GetCanDecrypt
908  *  nssCKFWMechanism_GetCanDigest
909  *  nssCKFWMechanism_GetCanSignRecover
910  *  nssCKFWMechanism_GetCanVerify
911  *  nssCKFWMechanism_GetCanVerifyRecover
912  *  nssCKFWMechanism_GetCanGenerate
913  *  nssCKFWMechanism_GetCanGenerateKeyPair
914  *  nssCKFWMechanism_GetCanWrap
915  *  nssCKFWMechanism_GetCanUnwrap
916  *  nssCKFWMechanism_GetCanDerive
917  *  nssCKFWMechanism_EncryptInit
918  *  nssCKFWMechanism_DecryptInit
919  *  nssCKFWMechanism_DigestInit
920  *  nssCKFWMechanism_SignInit
921  *  nssCKFWMechanism_SignRecoverInit
922  *  nssCKFWMechanism_VerifyInit
923  *  nssCKFWMechanism_VerifyRecoverInit
924  *  nssCKFWMechanism_GenerateKey
925  *  nssCKFWMechanism_GenerateKeyPair
926  *  nssCKFWMechanism_GetWrapKeyLength
927  *  nssCKFWMechanism_WrapKey
928  *  nssCKFWMechanism_UnwrapKey
929  *  nssCKFWMechanism_DeriveKey
930  */
931 
932 /*
933  * nssCKFWMechanism_Create
934  *
935  */
936 NSS_EXTERN NSSCKFWMechanism *
937 nssCKFWMechanism_Create(
938     NSSCKMDMechanism *mdMechanism,
939     NSSCKMDToken *mdToken,
940     NSSCKFWToken *fwToken,
941     NSSCKMDInstance *mdInstance,
942     NSSCKFWInstance *fwInstance);
943 
944 /*
945  * nssCKFWMechanism_Destroy
946  *
947  */
948 NSS_EXTERN void
949 nssCKFWMechanism_Destroy(
950     NSSCKFWMechanism *fwMechanism);
951 
952 /*
953  * nssCKFWMechanism_GetMDMechanism
954  *
955  */
956 
957 NSS_EXTERN NSSCKMDMechanism *
958 nssCKFWMechanism_GetMDMechanism(
959     NSSCKFWMechanism *fwMechanism);
960 
961 /*
962  * nssCKFWMechanism_GetMinKeySize
963  *
964  */
965 NSS_EXTERN CK_ULONG
966 nssCKFWMechanism_GetMinKeySize(
967     NSSCKFWMechanism *fwMechanism,
968     CK_RV *pError);
969 
970 /*
971  * nssCKFWMechanism_GetMaxKeySize
972  *
973  */
974 NSS_EXTERN CK_ULONG
975 nssCKFWMechanism_GetMaxKeySize(
976     NSSCKFWMechanism *fwMechanism,
977     CK_RV *pError);
978 
979 /*
980  * nssCKFWMechanism_GetInHardware
981  *
982  */
983 NSS_EXTERN CK_BBOOL
984 nssCKFWMechanism_GetInHardware(
985     NSSCKFWMechanism *fwMechanism,
986     CK_RV *pError);
987 
988 /*
989  * the following are determined automatically by which of the cryptographic
990  * functions are defined for this mechanism.
991  */
992 /*
993  * nssCKFWMechanism_GetCanEncrypt
994  *
995  */
996 NSS_EXTERN CK_BBOOL
997 nssCKFWMechanism_GetCanEncrypt(
998     NSSCKFWMechanism *fwMechanism,
999     CK_RV *pError);
1000 
1001 /*
1002  * nssCKFWMechanism_GetCanDecrypt
1003  *
1004  */
1005 NSS_EXTERN CK_BBOOL
1006 nssCKFWMechanism_GetCanDecrypt(
1007     NSSCKFWMechanism *fwMechanism,
1008     CK_RV *pError);
1009 
1010 /*
1011  * nssCKFWMechanism_GetCanDigest
1012  *
1013  */
1014 NSS_EXTERN CK_BBOOL
1015 nssCKFWMechanism_GetCanDigest(
1016     NSSCKFWMechanism *fwMechanism,
1017     CK_RV *pError);
1018 
1019 /*
1020  * nssCKFWMechanism_GetCanSign
1021  *
1022  */
1023 NSS_EXTERN CK_BBOOL
1024 nssCKFWMechanism_GetCanSign(
1025     NSSCKFWMechanism *fwMechanism,
1026     CK_RV *pError);
1027 
1028 /*
1029  * nssCKFWMechanism_GetCanSignRecover
1030  *
1031  */
1032 NSS_EXTERN CK_BBOOL
1033 nssCKFWMechanism_GetCanSignRecover(
1034     NSSCKFWMechanism *fwMechanism,
1035     CK_RV *pError);
1036 
1037 /*
1038  * nssCKFWMechanism_GetCanVerify
1039  *
1040  */
1041 NSS_EXTERN CK_BBOOL
1042 nssCKFWMechanism_GetCanVerify(
1043     NSSCKFWMechanism *fwMechanism,
1044     CK_RV *pError);
1045 
1046 /*
1047  * nssCKFWMechanism_GetCanVerifyRecover
1048  *
1049  */
1050 NSS_EXTERN CK_BBOOL
1051 nssCKFWMechanism_GetCanVerifyRecover(
1052     NSSCKFWMechanism *fwMechanism,
1053     CK_RV *pError);
1054 
1055 /*
1056  * nssCKFWMechanism_GetCanGenerate
1057  *
1058  */
1059 NSS_EXTERN CK_BBOOL
1060 nssCKFWMechanism_GetCanGenerate(
1061     NSSCKFWMechanism *fwMechanism,
1062     CK_RV *pError);
1063 
1064 /*
1065  * nssCKFWMechanism_GetCanGenerateKeyPair
1066  *
1067  */
1068 NSS_EXTERN CK_BBOOL
1069 nssCKFWMechanism_GetCanGenerateKeyPair(
1070     NSSCKFWMechanism *fwMechanism,
1071     CK_RV *pError);
1072 
1073 /*
1074  * nssCKFWMechanism_GetCanWrap
1075  *
1076  */
1077 NSS_EXTERN CK_BBOOL
1078 nssCKFWMechanism_GetCanWrap(
1079     NSSCKFWMechanism *fwMechanism,
1080     CK_RV *pError);
1081 
1082 /*
1083  * nssCKFWMechanism_GetCanUnwrap
1084  *
1085  */
1086 NSS_EXTERN CK_BBOOL
1087 nssCKFWMechanism_GetCanUnwrap(
1088     NSSCKFWMechanism *fwMechanism,
1089     CK_RV *pError);
1090 
1091 /*
1092  * nssCKFWMechanism_GetCanDerive
1093  *
1094  */
1095 NSS_EXTERN CK_BBOOL
1096 nssCKFWMechanism_GetCanDerive(
1097     NSSCKFWMechanism *fwMechanism,
1098     CK_RV *pError);
1099 
1100 /*
1101  *  nssCKFWMechanism_EncryptInit
1102  */
1103 NSS_EXTERN CK_RV
1104 nssCKFWMechanism_EncryptInit(
1105     NSSCKFWMechanism *fwMechanism,
1106     CK_MECHANISM *pMechanism,
1107     NSSCKFWSession *fwSession,
1108     NSSCKFWObject *fwObject);
1109 
1110 /*
1111  *  nssCKFWMechanism_DecryptInit
1112  */
1113 NSS_EXTERN CK_RV
1114 nssCKFWMechanism_DecryptInit(
1115     NSSCKFWMechanism *fwMechanism,
1116     CK_MECHANISM *pMechanism,
1117     NSSCKFWSession *fwSession,
1118     NSSCKFWObject *fwObject);
1119 
1120 /*
1121  *  nssCKFWMechanism_DigestInit
1122  */
1123 NSS_EXTERN CK_RV
1124 nssCKFWMechanism_DigestInit(
1125     NSSCKFWMechanism *fwMechanism,
1126     CK_MECHANISM *pMechanism,
1127     NSSCKFWSession *fwSession);
1128 
1129 /*
1130  *  nssCKFWMechanism_SignInit
1131  */
1132 NSS_EXTERN CK_RV
1133 nssCKFWMechanism_SignInit(
1134     NSSCKFWMechanism *fwMechanism,
1135     CK_MECHANISM *pMechanism,
1136     NSSCKFWSession *fwSession,
1137     NSSCKFWObject *fwObject);
1138 
1139 /*
1140  *  nssCKFWMechanism_SignRecoverInit
1141  */
1142 NSS_EXTERN CK_RV
1143 nssCKFWMechanism_SignRecoverInit(
1144     NSSCKFWMechanism *fwMechanism,
1145     CK_MECHANISM *pMechanism,
1146     NSSCKFWSession *fwSession,
1147     NSSCKFWObject *fwObject);
1148 
1149 /*
1150  *  nssCKFWMechanism_VerifyInit
1151  */
1152 NSS_EXTERN CK_RV
1153 nssCKFWMechanism_VerifyInit(
1154     NSSCKFWMechanism *fwMechanism,
1155     CK_MECHANISM *pMechanism,
1156     NSSCKFWSession *fwSession,
1157     NSSCKFWObject *fwObject);
1158 
1159 /*
1160  *  nssCKFWMechanism_VerifyRecoverInit
1161  */
1162 NSS_EXTERN CK_RV
1163 nssCKFWMechanism_VerifyRecoverInit(
1164     NSSCKFWMechanism *fwMechanism,
1165     CK_MECHANISM *pMechanism,
1166     NSSCKFWSession *fwSession,
1167     NSSCKFWObject *fwObject);
1168 
1169 /*
1170  * nssCKFWMechanism_GenerateKey
1171  */
1172 NSS_EXTERN NSSCKFWObject *
1173 nssCKFWMechanism_GenerateKey(
1174     NSSCKFWMechanism *fwMechanism,
1175     CK_MECHANISM_PTR pMechanism,
1176     NSSCKFWSession *fwSession,
1177     CK_ATTRIBUTE_PTR pTemplate,
1178     CK_ULONG ulAttributeCount,
1179     CK_RV *pError);
1180 
1181 /*
1182  * nssCKFWMechanism_GenerateKeyPair
1183  */
1184 NSS_EXTERN CK_RV
1185 nssCKFWMechanism_GenerateKeyPair(
1186     NSSCKFWMechanism *fwMechanism,
1187     CK_MECHANISM_PTR pMechanism,
1188     NSSCKFWSession *fwSession,
1189     CK_ATTRIBUTE_PTR pPublicKeyTemplate,
1190     CK_ULONG ulPublicKeyAttributeCount,
1191     CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
1192     CK_ULONG ulPrivateKeyAttributeCount,
1193     NSSCKFWObject **fwPublicKeyObject,
1194     NSSCKFWObject **fwPrivateKeyObject);
1195 
1196 /*
1197  * nssCKFWMechanism_GetWrapKeyLength
1198  */
1199 NSS_EXTERN CK_ULONG
1200 nssCKFWMechanism_GetWrapKeyLength(
1201     NSSCKFWMechanism *fwMechanism,
1202     CK_MECHANISM_PTR pMechanism,
1203     NSSCKFWSession *fwSession,
1204     NSSCKFWObject *fwWrappingKeyObject,
1205     NSSCKFWObject *fwObject,
1206     CK_RV *pError);
1207 
1208 /*
1209  * nssCKFWMechanism_WrapKey
1210  */
1211 NSS_EXTERN CK_RV
1212 nssCKFWMechanism_WrapKey(
1213     NSSCKFWMechanism *fwMechanism,
1214     CK_MECHANISM_PTR pMechanism,
1215     NSSCKFWSession *fwSession,
1216     NSSCKFWObject *fwWrappingKeyObject,
1217     NSSCKFWObject *fwObject,
1218     NSSItem *wrappedKey);
1219 
1220 /*
1221  * nssCKFWMechanism_UnwrapKey
1222  */
1223 NSS_EXTERN NSSCKFWObject *
1224 nssCKFWMechanism_UnwrapKey(
1225     NSSCKFWMechanism *fwMechanism,
1226     CK_MECHANISM_PTR pMechanism,
1227     NSSCKFWSession *fwSession,
1228     NSSCKFWObject *fwWrappingKeyObject,
1229     NSSItem *wrappedKey,
1230     CK_ATTRIBUTE_PTR pTemplate,
1231     CK_ULONG ulAttributeCount,
1232     CK_RV *pError);
1233 
1234 /*
1235  * nssCKFWMechanism_DeriveKey
1236  */
1237 NSS_EXTERN NSSCKFWObject *
1238 nssCKFWMechanism_DeriveKey(
1239     NSSCKFWMechanism *fwMechanism,
1240     CK_MECHANISM_PTR pMechanism,
1241     NSSCKFWSession *fwSession,
1242     NSSCKFWObject *fwBaseKeyObject,
1243     CK_ATTRIBUTE_PTR pTemplate,
1244     CK_ULONG ulAttributeCount,
1245     CK_RV *pError);
1246 
1247 /*
1248  * NSSCKFWCryptoOperation
1249  *
1250  *  -- create/destroy --
1251  *  nssCKFWCryptoOperation_Create
1252  *  nssCKFWCryptoOperation_Destroy
1253  *
1254  *  -- implement public accessors --
1255  *  nssCKFWCryptoOperation_GetMDCryptoOperation
1256  *  nssCKFWCryptoOperation_GetType
1257  *
1258  *  -- private accessors --
1259  *
1260  *  -- module fronts --
1261  * nssCKFWCryptoOperation_GetFinalLength
1262  * nssCKFWCryptoOperation_GetOperationLength
1263  * nssCKFWCryptoOperation_Final
1264  * nssCKFWCryptoOperation_Update
1265  * nssCKFWCryptoOperation_DigestUpdate
1266  * nssCKFWCryptoOperation_DigestKey
1267  * nssCKFWCryptoOperation_UpdateFinal
1268  */
1269 
1270 /*
1271  *  nssCKFWCrytoOperation_Create
1272  */
1273 NSS_EXTERN NSSCKFWCryptoOperation *
1274 nssCKFWCryptoOperation_Create(
1275     NSSCKMDCryptoOperation *mdOperation,
1276     NSSCKMDSession *mdSession,
1277     NSSCKFWSession *fwSession,
1278     NSSCKMDToken *mdToken,
1279     NSSCKFWToken *fwToken,
1280     NSSCKMDInstance *mdInstance,
1281     NSSCKFWInstance *fwInstance,
1282     NSSCKFWCryptoOperationType type,
1283     CK_RV *pError);
1284 
1285 /*
1286  *  nssCKFWCryptoOperation_Destroy
1287  */
1288 NSS_EXTERN void
1289 nssCKFWCryptoOperation_Destroy(
1290     NSSCKFWCryptoOperation *fwOperation);
1291 
1292 /*
1293  *  nssCKFWCryptoOperation_GetMDCryptoOperation
1294  */
1295 NSS_EXTERN NSSCKMDCryptoOperation *
1296 nssCKFWCryptoOperation_GetMDCryptoOperation(
1297     NSSCKFWCryptoOperation *fwOperation);
1298 
1299 /*
1300  *  nssCKFWCryptoOperation_GetType
1301  */
1302 NSS_EXTERN NSSCKFWCryptoOperationType
1303 nssCKFWCryptoOperation_GetType(
1304     NSSCKFWCryptoOperation *fwOperation);
1305 
1306 /*
1307  * nssCKFWCryptoOperation_GetFinalLength
1308  */
1309 NSS_EXTERN CK_ULONG
1310 nssCKFWCryptoOperation_GetFinalLength(
1311     NSSCKFWCryptoOperation *fwOperation,
1312     CK_RV *pError);
1313 
1314 /*
1315  * nssCKFWCryptoOperation_GetOperationLength
1316  */
1317 NSS_EXTERN CK_ULONG
1318 nssCKFWCryptoOperation_GetOperationLength(
1319     NSSCKFWCryptoOperation *fwOperation,
1320     NSSItem *inputBuffer,
1321     CK_RV *pError);
1322 
1323 /*
1324  * nssCKFWCryptoOperation_Final
1325  */
1326 NSS_EXTERN CK_RV
1327 nssCKFWCryptoOperation_Final(
1328     NSSCKFWCryptoOperation *fwOperation,
1329     NSSItem *outputBuffer);
1330 
1331 /*
1332  * nssCKFWCryptoOperation_Update
1333  */
1334 NSS_EXTERN CK_RV
1335 nssCKFWCryptoOperation_Update(
1336     NSSCKFWCryptoOperation *fwOperation,
1337     NSSItem *inputBuffer,
1338     NSSItem *outputBuffer);
1339 
1340 /*
1341  * nssCKFWCryptoOperation_DigestUpdate
1342  */
1343 NSS_EXTERN CK_RV
1344 nssCKFWCryptoOperation_DigestUpdate(
1345     NSSCKFWCryptoOperation *fwOperation,
1346     NSSItem *inputBuffer);
1347 
1348 /*
1349  * nssCKFWCryptoOperation_DigestKey
1350  */
1351 NSS_EXTERN CK_RV
1352 nssCKFWCryptoOperation_DigestKey(
1353     NSSCKFWCryptoOperation *fwOperation,
1354     NSSCKFWObject *fwKey);
1355 
1356 /*
1357  * nssCKFWCryptoOperation_UpdateFinal
1358  */
1359 NSS_EXTERN CK_RV
1360 nssCKFWCryptoOperation_UpdateFinal(
1361     NSSCKFWCryptoOperation *fwOperation,
1362     NSSItem *inputBuffer,
1363     NSSItem *outputBuffer);
1364 
1365 /*
1366  * nssCKFWCryptoOperation_UpdateCombo
1367  */
1368 NSS_EXTERN CK_RV
1369 nssCKFWCryptoOperation_UpdateCombo(
1370     NSSCKFWCryptoOperation *fwOperation,
1371     NSSCKFWCryptoOperation *fwPeerOperation,
1372     NSSItem *inputBuffer,
1373     NSSItem *outputBuffer);
1374 
1375 /*
1376  * NSSCKFWSession
1377  *
1378  *  -- create/destroy --
1379  *  nssCKFWSession_Create
1380  *  nssCKFWSession_Destroy
1381  *
1382  *  -- implement public accessors --
1383  *  nssCKFWSession_GetMDSession
1384  *  nssCKFWSession_GetArena
1385  *  nssCKFWSession_CallNotification
1386  *  nssCKFWSession_IsRWSession
1387  *  nssCKFWSession_IsSO
1388  *  nssCKFWSession_GetCurrentCryptoOperation
1389  *
1390  *  -- private accessors --
1391  *  nssCKFWSession_GetFWSlot
1392  *  nssCKFWSession_GetSessionState
1393  *  nssCKFWSession_SetFWFindObjects
1394  *  nssCKFWSession_GetFWFindObjects
1395  *  nssCKFWSession_SetMDSession
1396  *  nssCKFWSession_SetHandle
1397  *  nssCKFWSession_GetHandle
1398  *  nssCKFWSession_RegisterSessionObject
1399  *  nssCKFWSession_DeregisterSessionObject
1400  *  nssCKFWSession_SetCurrentCryptoOperation
1401  *
1402  *  -- module fronts --
1403  *  nssCKFWSession_GetDeviceError
1404  *  nssCKFWSession_Login
1405  *  nssCKFWSession_Logout
1406  *  nssCKFWSession_InitPIN
1407  *  nssCKFWSession_SetPIN
1408  *  nssCKFWSession_GetOperationStateLen
1409  *  nssCKFWSession_GetOperationState
1410  *  nssCKFWSession_SetOperationState
1411  *  nssCKFWSession_CreateObject
1412  *  nssCKFWSession_CopyObject
1413  *  nssCKFWSession_FindObjectsInit
1414  *  nssCKFWSession_SeedRandom
1415  *  nssCKFWSession_GetRandom
1416  *  nssCKFWSession_Final
1417  *  nssCKFWSession_Update
1418  *  nssCKFWSession_DigestUpdate
1419  *  nssCKFWSession_DigestKey
1420  *  nssCKFWSession_UpdateFinal
1421  *  nssCKFWSession_UpdateCombo
1422  */
1423 
1424 /*
1425  * nssCKFWSession_Create
1426  *
1427  */
1428 NSS_EXTERN NSSCKFWSession *
1429 nssCKFWSession_Create(
1430     NSSCKFWToken *fwToken,
1431     CK_BBOOL rw,
1432     CK_VOID_PTR pApplication,
1433     CK_NOTIFY Notify,
1434     CK_RV *pError);
1435 
1436 /*
1437  * nssCKFWSession_Destroy
1438  *
1439  */
1440 NSS_EXTERN CK_RV
1441 nssCKFWSession_Destroy(
1442     NSSCKFWSession *fwSession,
1443     CK_BBOOL removeFromTokenHash);
1444 
1445 /*
1446  * nssCKFWSession_GetMDSession
1447  *
1448  */
1449 NSS_EXTERN NSSCKMDSession *
1450 nssCKFWSession_GetMDSession(
1451     NSSCKFWSession *fwSession);
1452 
1453 /*
1454  * nssCKFWSession_GetArena
1455  *
1456  */
1457 NSS_EXTERN NSSArena *
1458 nssCKFWSession_GetArena(
1459     NSSCKFWSession *fwSession,
1460     CK_RV *pError);
1461 
1462 /*
1463  * nssCKFWSession_CallNotification
1464  *
1465  */
1466 NSS_EXTERN CK_RV
1467 nssCKFWSession_CallNotification(
1468     NSSCKFWSession *fwSession,
1469     CK_NOTIFICATION event);
1470 
1471 /*
1472  * nssCKFWSession_IsRWSession
1473  *
1474  */
1475 NSS_EXTERN CK_BBOOL
1476 nssCKFWSession_IsRWSession(
1477     NSSCKFWSession *fwSession);
1478 
1479 /*
1480  * nssCKFWSession_IsSO
1481  *
1482  */
1483 NSS_EXTERN CK_BBOOL
1484 nssCKFWSession_IsSO(
1485     NSSCKFWSession *fwSession);
1486 
1487 /*
1488  * nssCKFWSession_GetFWSlot
1489  *
1490  */
1491 NSS_EXTERN NSSCKFWSlot *
1492 nssCKFWSession_GetFWSlot(
1493     NSSCKFWSession *fwSession);
1494 
1495 /*
1496  * nssCFKWSession_GetSessionState
1497  *
1498  */
1499 NSS_EXTERN CK_STATE
1500 nssCKFWSession_GetSessionState(
1501     NSSCKFWSession *fwSession);
1502 
1503 /*
1504  * nssCKFWSession_SetFWFindObjects
1505  *
1506  */
1507 NSS_EXTERN CK_RV
1508 nssCKFWSession_SetFWFindObjects(
1509     NSSCKFWSession *fwSession,
1510     NSSCKFWFindObjects *fwFindObjects);
1511 
1512 /*
1513  * nssCKFWSession_GetFWFindObjects
1514  *
1515  */
1516 NSS_EXTERN NSSCKFWFindObjects *
1517 nssCKFWSession_GetFWFindObjects(
1518     NSSCKFWSession *fwSesssion,
1519     CK_RV *pError);
1520 
1521 /*
1522  * nssCKFWSession_SetMDSession
1523  *
1524  */
1525 NSS_EXTERN CK_RV
1526 nssCKFWSession_SetMDSession(
1527     NSSCKFWSession *fwSession,
1528     NSSCKMDSession *mdSession);
1529 
1530 /*
1531  * nssCKFWSession_SetHandle
1532  *
1533  */
1534 NSS_EXTERN CK_RV
1535 nssCKFWSession_SetHandle(
1536     NSSCKFWSession *fwSession,
1537     CK_SESSION_HANDLE hSession);
1538 
1539 /*
1540  * nssCKFWSession_GetHandle
1541  *
1542  */
1543 NSS_EXTERN CK_SESSION_HANDLE
1544 nssCKFWSession_GetHandle(
1545     NSSCKFWSession *fwSession);
1546 
1547 /*
1548  * nssCKFWSession_RegisterSessionObject
1549  *
1550  */
1551 NSS_EXTERN CK_RV
1552 nssCKFWSession_RegisterSessionObject(
1553     NSSCKFWSession *fwSession,
1554     NSSCKFWObject *fwObject);
1555 
1556 /*
1557  * nssCKFWSession_DeregisterSessionObject
1558  *
1559  */
1560 NSS_EXTERN CK_RV
1561 nssCKFWSession_DeregisterSessionObject(
1562     NSSCKFWSession *fwSession,
1563     NSSCKFWObject *fwObject);
1564 
1565 /*
1566  * nssCKFWSession_GetDeviceError
1567  *
1568  */
1569 NSS_EXTERN CK_ULONG
1570 nssCKFWSession_GetDeviceError(
1571     NSSCKFWSession *fwSession);
1572 
1573 /*
1574  * nssCKFWSession_Login
1575  *
1576  */
1577 NSS_EXTERN CK_RV
1578 nssCKFWSession_Login(
1579     NSSCKFWSession *fwSession,
1580     CK_USER_TYPE userType,
1581     NSSItem *pin);
1582 
1583 /*
1584  * nssCKFWSession_Logout
1585  *
1586  */
1587 NSS_EXTERN CK_RV
1588 nssCKFWSession_Logout(
1589     NSSCKFWSession *fwSession);
1590 
1591 /*
1592  * nssCKFWSession_InitPIN
1593  *
1594  */
1595 NSS_EXTERN CK_RV
1596 nssCKFWSession_InitPIN(
1597     NSSCKFWSession *fwSession,
1598     NSSItem *pin);
1599 
1600 /*
1601  * nssCKFWSession_SetPIN
1602  *
1603  */
1604 NSS_EXTERN CK_RV
1605 nssCKFWSession_SetPIN(
1606     NSSCKFWSession *fwSession,
1607     NSSItem *newPin,
1608     NSSItem *oldPin);
1609 
1610 /*
1611  * nssCKFWSession_GetOperationStateLen
1612  *
1613  */
1614 NSS_EXTERN CK_ULONG
1615 nssCKFWSession_GetOperationStateLen(
1616     NSSCKFWSession *fwSession,
1617     CK_RV *pError);
1618 
1619 /*
1620  * nssCKFWSession_GetOperationState
1621  *
1622  */
1623 NSS_EXTERN CK_RV
1624 nssCKFWSession_GetOperationState(
1625     NSSCKFWSession *fwSession,
1626     NSSItem *buffer);
1627 
1628 /*
1629  * nssCKFWSession_SetOperationState
1630  *
1631  */
1632 NSS_EXTERN CK_RV
1633 nssCKFWSession_SetOperationState(
1634     NSSCKFWSession *fwSession,
1635     NSSItem *state,
1636     NSSCKFWObject *encryptionKey,
1637     NSSCKFWObject *authenticationKey);
1638 
1639 /*
1640  * nssCKFWSession_CreateObject
1641  *
1642  */
1643 NSS_EXTERN NSSCKFWObject *
1644 nssCKFWSession_CreateObject(
1645     NSSCKFWSession *fwSession,
1646     CK_ATTRIBUTE_PTR pTemplate,
1647     CK_ULONG ulAttributeCount,
1648     CK_RV *pError);
1649 
1650 /*
1651  * nssCKFWSession_CopyObject
1652  *
1653  */
1654 NSS_EXTERN NSSCKFWObject *
1655 nssCKFWSession_CopyObject(
1656     NSSCKFWSession *fwSession,
1657     NSSCKFWObject *object,
1658     CK_ATTRIBUTE_PTR pTemplate,
1659     CK_ULONG ulAttributeCount,
1660     CK_RV *pError);
1661 
1662 /*
1663  * nssCKFWSession_FindObjectsInit
1664  *
1665  */
1666 NSS_EXTERN NSSCKFWFindObjects *
1667 nssCKFWSession_FindObjectsInit(
1668     NSSCKFWSession *fwSession,
1669     CK_ATTRIBUTE_PTR pTemplate,
1670     CK_ULONG ulAttributeCount,
1671     CK_RV *pError);
1672 
1673 /*
1674  * nssCKFWSession_SetCurrentCryptoOperation
1675  */
1676 NSS_IMPLEMENT void
1677 nssCKFWSession_SetCurrentCryptoOperation(
1678     NSSCKFWSession *fwSession,
1679     NSSCKFWCryptoOperation *fwOperation,
1680     NSSCKFWCryptoOperationState state);
1681 
1682 /*
1683  * nssCKFWSession_GetCurrentCryptoOperation
1684  */
1685 NSS_IMPLEMENT NSSCKFWCryptoOperation *
1686 nssCKFWSession_GetCurrentCryptoOperation(
1687     NSSCKFWSession *fwSession,
1688     NSSCKFWCryptoOperationState state);
1689 
1690 /*
1691  * nssCKFWSession_Final
1692  * (terminate a cryptographic operation and get the result)
1693  */
1694 NSS_IMPLEMENT CK_RV
1695 nssCKFWSession_Final(
1696     NSSCKFWSession *fwSession,
1697     NSSCKFWCryptoOperationType type,
1698     NSSCKFWCryptoOperationState state,
1699     CK_BYTE_PTR outBuf,
1700     CK_ULONG_PTR outBufLen);
1701 
1702 /*
1703  * nssCKFWSession_Update
1704  * (get the next step of an encrypt/decrypt operation)
1705  */
1706 NSS_IMPLEMENT CK_RV
1707 nssCKFWSession_Update(
1708     NSSCKFWSession *fwSession,
1709     NSSCKFWCryptoOperationType type,
1710     NSSCKFWCryptoOperationState state,
1711     CK_BYTE_PTR inBuf,
1712     CK_ULONG inBufLen,
1713     CK_BYTE_PTR outBuf,
1714     CK_ULONG_PTR outBufLen);
1715 
1716 /*
1717  * nssCKFWSession_DigestUpdate
1718  * (do the next step of an digest/sign/verify operation)
1719  */
1720 NSS_IMPLEMENT CK_RV
1721 nssCKFWSession_DigestUpdate(
1722     NSSCKFWSession *fwSession,
1723     NSSCKFWCryptoOperationType type,
1724     NSSCKFWCryptoOperationState state,
1725     CK_BYTE_PTR inBuf,
1726     CK_ULONG inBufLen);
1727 
1728 /*
1729  * nssCKFWSession_DigestKey
1730  * (do the next step of an digest/sign/verify operation)
1731  */
1732 NSS_IMPLEMENT CK_RV
1733 nssCKFWSession_DigestKey(
1734     NSSCKFWSession *fwSession,
1735     NSSCKFWObject *fwKey);
1736 
1737 /*
1738  * nssCKFWSession_UpdateFinal
1739  * (do a single-step of a cryptographic operation and get the result)
1740  */
1741 NSS_IMPLEMENT CK_RV
1742 nssCKFWSession_UpdateFinal(
1743     NSSCKFWSession *fwSession,
1744     NSSCKFWCryptoOperationType type,
1745     NSSCKFWCryptoOperationState state,
1746     CK_BYTE_PTR inBuf,
1747     CK_ULONG inBufLen,
1748     CK_BYTE_PTR outBuf,
1749     CK_ULONG_PTR outBufLen);
1750 
1751 /*
1752  * nssCKFWSession_UpdateCombo
1753  * (do a combination encrypt/decrypt and sign/digest/verify operation)
1754  */
1755 NSS_IMPLEMENT CK_RV
1756 nssCKFWSession_UpdateCombo(
1757     NSSCKFWSession *fwSession,
1758     NSSCKFWCryptoOperationType encryptType,
1759     NSSCKFWCryptoOperationType digestType,
1760     NSSCKFWCryptoOperationState digestState,
1761     CK_BYTE_PTR inBuf,
1762     CK_ULONG inBufLen,
1763     CK_BYTE_PTR outBuf,
1764     CK_ULONG_PTR outBufLen);
1765 
1766 /*
1767  * nssCKFWSession_SeedRandom
1768  *
1769  */
1770 NSS_EXTERN CK_RV
1771 nssCKFWSession_SeedRandom(
1772     NSSCKFWSession *fwSession,
1773     NSSItem *seed);
1774 
1775 /*
1776  * nssCKFWSession_GetRandom
1777  *
1778  */
1779 NSS_EXTERN CK_RV
1780 nssCKFWSession_GetRandom(
1781     NSSCKFWSession *fwSession,
1782     NSSItem *buffer);
1783 
1784 /*
1785  * NSSCKFWObject
1786  *
1787  * -- create/destroy --
1788  *  nssCKFWObject_Create
1789  *  nssCKFWObject_Finalize
1790  *  nssCKFWObject_Destroy
1791  *
1792  * -- implement public accessors --
1793  *  nssCKFWObject_GetMDObject
1794  *  nssCKFWObject_GetArena
1795  *
1796  * -- private accessors --
1797  *  nssCKFWObject_SetHandle
1798  *  nssCKFWObject_GetHandle
1799  *
1800  * -- module fronts --
1801  *  nssCKFWObject_IsTokenObject
1802  *  nssCKFWObject_GetAttributeCount
1803  *  nssCKFWObject_GetAttributeTypes
1804  *  nssCKFWObject_GetAttributeSize
1805  *  nssCKFWObject_GetAttribute
1806  *  nssCKFWObject_SetAttribute
1807  *  nssCKFWObject_GetObjectSize
1808  */
1809 
1810 /*
1811  * nssCKFWObject_Create
1812  *
1813  */
1814 NSS_EXTERN NSSCKFWObject *
1815 nssCKFWObject_Create(
1816     NSSArena *arena,
1817     NSSCKMDObject *mdObject,
1818     NSSCKFWSession *fwSession,
1819     NSSCKFWToken *fwToken,
1820     NSSCKFWInstance *fwInstance,
1821     CK_RV *pError);
1822 
1823 /*
1824  * nssCKFWObject_Finalize
1825  *
1826  */
1827 NSS_EXTERN void
1828 nssCKFWObject_Finalize(
1829     NSSCKFWObject *fwObject,
1830     PRBool removeFromHash);
1831 
1832 /*
1833  * nssCKFWObject_Destroy
1834  *
1835  */
1836 NSS_EXTERN void
1837 nssCKFWObject_Destroy(
1838     NSSCKFWObject *fwObject);
1839 
1840 /*
1841  * nssCKFWObject_GetMDObject
1842  *
1843  */
1844 NSS_EXTERN NSSCKMDObject *
1845 nssCKFWObject_GetMDObject(
1846     NSSCKFWObject *fwObject);
1847 
1848 /*
1849  * nssCKFWObject_GetArena
1850  *
1851  */
1852 NSS_EXTERN NSSArena *
1853 nssCKFWObject_GetArena(
1854     NSSCKFWObject *fwObject,
1855     CK_RV *pError);
1856 
1857 /*
1858  * nssCKFWObject_SetHandle
1859  *
1860  */
1861 NSS_EXTERN CK_RV
1862 nssCKFWObject_SetHandle(
1863     NSSCKFWObject *fwObject,
1864     CK_OBJECT_HANDLE hObject);
1865 
1866 /*
1867  * nssCKFWObject_GetHandle
1868  *
1869  */
1870 NSS_EXTERN CK_OBJECT_HANDLE
1871 nssCKFWObject_GetHandle(
1872     NSSCKFWObject *fwObject);
1873 
1874 /*
1875  * nssCKFWObject_IsTokenObject
1876  *
1877  */
1878 NSS_EXTERN CK_BBOOL
1879 nssCKFWObject_IsTokenObject(
1880     NSSCKFWObject *fwObject);
1881 
1882 /*
1883  * nssCKFWObject_GetAttributeCount
1884  *
1885  */
1886 NSS_EXTERN CK_ULONG
1887 nssCKFWObject_GetAttributeCount(
1888     NSSCKFWObject *fwObject,
1889     CK_RV *pError);
1890 
1891 /*
1892  * nssCKFWObject_GetAttributeTypes
1893  *
1894  */
1895 NSS_EXTERN CK_RV
1896 nssCKFWObject_GetAttributeTypes(
1897     NSSCKFWObject *fwObject,
1898     CK_ATTRIBUTE_TYPE_PTR typeArray,
1899     CK_ULONG ulCount);
1900 
1901 /*
1902  * nssCKFWObject_GetAttributeSize
1903  *
1904  */
1905 NSS_EXTERN CK_ULONG
1906 nssCKFWObject_GetAttributeSize(
1907     NSSCKFWObject *fwObject,
1908     CK_ATTRIBUTE_TYPE attribute,
1909     CK_RV *pError);
1910 
1911 /*
1912  * nssCKFWObject_GetAttribute
1913  *
1914  * Usual NSS allocation rules:
1915  * If itemOpt is not NULL, it will be returned; otherwise an NSSItem
1916  * will be allocated.  If itemOpt is not NULL but itemOpt->data is,
1917  * the buffer will be allocated; otherwise, the buffer will be used.
1918  * Any allocations will come from the optional arena, if one is
1919  * specified.
1920  */
1921 NSS_EXTERN NSSItem *
1922 nssCKFWObject_GetAttribute(
1923     NSSCKFWObject *fwObject,
1924     CK_ATTRIBUTE_TYPE attribute,
1925     NSSItem *itemOpt,
1926     NSSArena *arenaOpt,
1927     CK_RV *pError);
1928 
1929 /*
1930  * nssCKFWObject_SetAttribute
1931  *
1932  */
1933 NSS_EXTERN CK_RV
1934 nssCKFWObject_SetAttribute(
1935     NSSCKFWObject *fwObject,
1936     NSSCKFWSession *fwSession,
1937     CK_ATTRIBUTE_TYPE attribute,
1938     NSSItem *value);
1939 
1940 /*
1941  * nssCKFWObject_GetObjectSize
1942  *
1943  */
1944 NSS_EXTERN CK_ULONG
1945 nssCKFWObject_GetObjectSize(
1946     NSSCKFWObject *fwObject,
1947     CK_RV *pError);
1948 
1949 /*
1950  * NSSCKFWFindObjects
1951  *
1952  *  -- create/destroy --
1953  *  nssCKFWFindObjects_Create
1954  *  nssCKFWFindObjects_Destroy
1955  *
1956  *  -- implement public accessors --
1957  *  nssCKFWFindObjects_GetMDFindObjects
1958  *
1959  *  -- private accessors --
1960  *
1961  *  -- module fronts --
1962  *  nssCKFWFindObjects_Next
1963  */
1964 
1965 /*
1966  * nssCKFWFindObjects_Create
1967  *
1968  */
1969 NSS_EXTERN NSSCKFWFindObjects *
1970 nssCKFWFindObjects_Create(
1971     NSSCKFWSession *fwSession,
1972     NSSCKFWToken *fwToken,
1973     NSSCKFWInstance *fwInstance,
1974     NSSCKMDFindObjects *mdFindObjects1,
1975     NSSCKMDFindObjects *mdFindObjects2,
1976     CK_RV *pError);
1977 
1978 /*
1979  * nssCKFWFindObjects_Destroy
1980  *
1981  */
1982 NSS_EXTERN void
1983 nssCKFWFindObjects_Destroy(
1984     NSSCKFWFindObjects *fwFindObjects);
1985 
1986 /*
1987  * nssCKFWFindObjects_GetMDFindObjects
1988  *
1989  */
1990 NSS_EXTERN NSSCKMDFindObjects *
1991 nssCKFWFindObjects_GetMDFindObjects(
1992     NSSCKFWFindObjects *fwFindObjects);
1993 
1994 /*
1995  * nssCKFWFindObjects_Next
1996  *
1997  */
1998 NSS_EXTERN NSSCKFWObject *
1999 nssCKFWFindObjects_Next(
2000     NSSCKFWFindObjects *fwFindObjects,
2001     NSSArena *arenaOpt,
2002     CK_RV *pError);
2003 
2004 /*
2005  * NSSCKFWMutex
2006  *
2007  *  nssCKFWMutex_Create
2008  *  nssCKFWMutex_Destroy
2009  *  nssCKFWMutex_Lock
2010  *  nssCKFWMutex_Unlock
2011  *
2012  */
2013 
2014 /*
2015  * nssCKFWMutex_Create
2016  *
2017  */
2018 NSS_EXTERN NSSCKFWMutex *
2019 nssCKFWMutex_Create(
2020     CK_C_INITIALIZE_ARGS_PTR pInitArgs,
2021     CryptokiLockingState LockingState,
2022     NSSArena *arena,
2023     CK_RV *pError);
2024 
2025 /*
2026  * nssCKFWMutex_Destroy
2027  *
2028  */
2029 NSS_EXTERN CK_RV
2030 nssCKFWMutex_Destroy(
2031     NSSCKFWMutex *mutex);
2032 
2033 /*
2034  * nssCKFWMutex_Lock
2035  *
2036  */
2037 NSS_EXTERN CK_RV
2038 nssCKFWMutex_Lock(
2039     NSSCKFWMutex *mutex);
2040 
2041 /*
2042  * nssCKFWMutex_Unlock
2043  *
2044  */
2045 NSS_EXTERN CK_RV
2046 nssCKFWMutex_Unlock(
2047     NSSCKFWMutex *mutex);
2048 
2049 #endif /* CKFW_H */
2050