ckfw.h (39315B)
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 const NSSItem *oldPin, 1608 NSSItem *newPin); 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 */