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 * This file implements PKCS 11 on top of our existing security modules
6 *
7 * For more information about PKCS 11 See PKCS 11 Token Inteface Standard.
8 * This implementation has two slots:
9 * slot 1 is our generic crypto support. It does not require login
10 * (unless you've enabled FIPS). It supports Public Key ops, and all they
11 * bulk ciphers and hashes. It can also support Private Key ops for imported
12 * Private keys. It does not have any token storage.
13 * slot 2 is our private key support. It requires a login before use. It
14 * can store Private Keys and Certs as token objects. Currently only private
15 * keys and their associated Certificates are saved on the token.
16 *
17 * In this implementation, session objects are only visible to the session
18 * that created or generated them.
19 */
20 #include "seccomon.h"
21 #include "softoken.h"
22 #include "lowkeyi.h"
23 #include "pkcs11.h"
24 #include "pkcs11i.h"
25 #include "prenv.h"
26 #include "prprf.h"
27
28 #include <ctype.h>
29
30 #ifdef XP_UNIX
31 #define NSS_AUDIT_WITH_SYSLOG 1
32 #include <syslog.h>
33 #include <unistd.h>
34 #endif
35
36 #ifdef LINUX
37 #include <pthread.h>
38 #include <dlfcn.h>
39 #define LIBAUDIT_NAME "libaudit.so.1"
40 #ifndef AUDIT_CRYPTO_TEST_USER
41 #define AUDIT_CRYPTO_TEST_USER 2400 /* Crypto test results */
42 #define AUDIT_CRYPTO_PARAM_CHANGE_USER 2401 /* Crypto attribute change */
43 #define AUDIT_CRYPTO_LOGIN 2402 /* Logged in as crypto officer */
44 #define AUDIT_CRYPTO_LOGOUT 2403 /* Logged out from crypto */
45 #define AUDIT_CRYPTO_KEY_USER 2404 /* Create,delete,negotiate */
46 #define AUDIT_CRYPTO_FAILURE_USER 2405 /* Fail decrypt,encrypt,randomize */
47 #endif
48 static void *libaudit_handle;
49 static int (*audit_open_func)(void);
50 static void (*audit_close_func)(int fd);
51 static int (*audit_log_user_message_func)(int audit_fd, int type,
52 const char *message, const char *hostname, const char *addr,
53 const char *tty, int result);
54 static int (*audit_send_user_message_func)(int fd, int type,
55 const char *message);
56
57 static pthread_once_t libaudit_once_control = PTHREAD_ONCE_INIT;
58
59 static void
libaudit_init(void)60 libaudit_init(void)
61 {
62 libaudit_handle = dlopen(LIBAUDIT_NAME, RTLD_LAZY);
63 if (!libaudit_handle) {
64 return;
65 }
66 audit_open_func = dlsym(libaudit_handle, "audit_open");
67 audit_close_func = dlsym(libaudit_handle, "audit_close");
68 /*
69 * audit_send_user_message is the older function.
70 * audit_log_user_message, if available, is preferred.
71 */
72 audit_log_user_message_func = dlsym(libaudit_handle,
73 "audit_log_user_message");
74 if (!audit_log_user_message_func) {
75 audit_send_user_message_func = dlsym(libaudit_handle,
76 "audit_send_user_message");
77 }
78 if (!audit_open_func || !audit_close_func ||
79 (!audit_log_user_message_func && !audit_send_user_message_func)) {
80 dlclose(libaudit_handle);
81 libaudit_handle = NULL;
82 audit_open_func = NULL;
83 audit_close_func = NULL;
84 audit_log_user_message_func = NULL;
85 audit_send_user_message_func = NULL;
86 }
87 }
88 #endif /* LINUX */
89
90 /*
91 * ******************** Password Utilities *******************************
92 */
93 static PRBool isLoggedIn = PR_FALSE;
94 static PRBool isLevel2 = PR_TRUE;
95 PRBool sftk_fatalError = PR_FALSE;
96
97 /*
98 * This function returns
99 * - CKR_PIN_INVALID if the password/PIN is not a legal UTF8 string
100 * - CKR_PIN_LEN_RANGE if the password/PIN is too short or does not
101 * consist of characters from three or more character classes.
102 * - CKR_OK otherwise
103 *
104 * The minimum password/PIN length is FIPS_MIN_PIN Unicode characters.
105 * We define five character classes: digits (0-9), ASCII lowercase letters,
106 * ASCII uppercase letters, ASCII non-alphanumeric characters (such as
107 * space and punctuation marks), and non-ASCII characters. If an ASCII
108 * uppercase letter is the first character of the password/PIN, the
109 * uppercase letter is not counted toward its character class. Similarly,
110 * if a digit is the last character of the password/PIN, the digit is not
111 * counted toward its character class.
112 *
113 * Although NSC_SetPIN and NSC_InitPIN already do the maximum and minimum
114 * password/PIN length checks, they check the length in bytes as opposed
115 * to characters. To meet the minimum password/PIN guessing probability
116 * requirements in FIPS 140-2, we need to check the length in characters.
117 */
118 static CK_RV
sftk_newPinCheck(CK_CHAR_PTR pPin,CK_ULONG ulPinLen)119 sftk_newPinCheck(CK_CHAR_PTR pPin, CK_ULONG ulPinLen)
120 {
121 unsigned int i;
122 int nchar = 0; /* number of characters */
123 int ntrail = 0; /* number of trailing bytes to follow */
124 int ndigit = 0; /* number of decimal digits */
125 int nlower = 0; /* number of ASCII lowercase letters */
126 int nupper = 0; /* number of ASCII uppercase letters */
127 int nnonalnum = 0; /* number of ASCII non-alphanumeric characters */
128 int nnonascii = 0; /* number of non-ASCII characters */
129 int nclass; /* number of character classes */
130
131 for (i = 0; i < ulPinLen; i++) {
132 unsigned int byte = pPin[i];
133
134 if (ntrail) {
135 if ((byte & 0xc0) != 0x80) {
136 /* illegal */
137 nchar = -1;
138 break;
139 }
140 if (--ntrail == 0) {
141 nchar++;
142 nnonascii++;
143 }
144 continue;
145 }
146 if ((byte & 0x80) == 0x00) {
147 /* single-byte (ASCII) character */
148 nchar++;
149 if (isdigit(byte)) {
150 if (i < ulPinLen - 1) {
151 ndigit++;
152 }
153 } else if (islower(byte)) {
154 nlower++;
155 } else if (isupper(byte)) {
156 if (i > 0) {
157 nupper++;
158 }
159 } else {
160 nnonalnum++;
161 }
162 } else if ((byte & 0xe0) == 0xc0) {
163 /* leading byte of two-byte character */
164 ntrail = 1;
165 } else if ((byte & 0xf0) == 0xe0) {
166 /* leading byte of three-byte character */
167 ntrail = 2;
168 } else if ((byte & 0xf8) == 0xf0) {
169 /* leading byte of four-byte character */
170 ntrail = 3;
171 } else {
172 /* illegal */
173 nchar = -1;
174 break;
175 }
176 }
177 if (nchar == -1) {
178 /* illegal UTF8 string */
179 return CKR_PIN_INVALID;
180 }
181 if (nchar < FIPS_MIN_PIN) {
182 return CKR_PIN_LEN_RANGE;
183 }
184 nclass = (ndigit != 0) + (nlower != 0) + (nupper != 0) +
185 (nnonalnum != 0) + (nnonascii != 0);
186 if (nclass < 3) {
187 return CKR_PIN_LEN_RANGE;
188 }
189 return CKR_OK;
190 }
191
192 /* FIPS required checks before any useful cryptographic services */
193 static CK_RV
sftk_fipsCheck(void)194 sftk_fipsCheck(void)
195 {
196 if (sftk_fatalError)
197 return CKR_DEVICE_ERROR;
198 if (isLevel2 && !isLoggedIn)
199 return CKR_USER_NOT_LOGGED_IN;
200 return CKR_OK;
201 }
202
203 #define SFTK_FIPSCHECK() \
204 CK_RV rv; \
205 if ((rv = sftk_fipsCheck()) != CKR_OK) \
206 return rv;
207
208 #define SFTK_FIPSFATALCHECK() \
209 if (sftk_fatalError) \
210 return CKR_DEVICE_ERROR;
211
212 /* grab an attribute out of a raw template */
213 void *
fc_getAttribute(CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_ATTRIBUTE_TYPE type)214 fc_getAttribute(CK_ATTRIBUTE_PTR pTemplate,
215 CK_ULONG ulCount, CK_ATTRIBUTE_TYPE type)
216 {
217 int i;
218
219 for (i = 0; i < (int)ulCount; i++) {
220 if (pTemplate[i].type == type) {
221 return pTemplate[i].pValue;
222 }
223 }
224 return NULL;
225 }
226
227 #define __PASTE(x, y) x##y
228
229 /* ------------- forward declare all the NSC_ functions ------------- */
230 #undef CK_NEED_ARG_LIST
231 #undef CK_PKCS11_FUNCTION_INFO
232
233 #define CK_PKCS11_3_0 1
234
235 #define CK_PKCS11_FUNCTION_INFO(name) CK_RV __PASTE(NS, name)
236 #define CK_NEED_ARG_LIST 1
237
238 #include "pkcs11f.h"
239
240 /* ------------- forward declare all the FIPS functions ------------- */
241 #undef CK_NEED_ARG_LIST
242 #undef CK_PKCS11_FUNCTION_INFO
243
244 #define CK_PKCS11_FUNCTION_INFO(name) CK_RV __PASTE(F, name)
245 #define CK_NEED_ARG_LIST 1
246
247 #include "pkcs11f.h"
248
249 /* ------------- build the CK_CRYPTO_TABLE ------------------------- */
250 static CK_FUNCTION_LIST_3_0 sftk_fipsTable = {
251 { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
252
253 #undef CK_NEED_ARG_LIST
254 #undef CK_PKCS11_FUNCTION_INFO
255
256 #define CK_PKCS11_FUNCTION_INFO(name) \
257 __PASTE(F, name) \
258 ,
259
260 #include "pkcs11f.h"
261
262 };
263
264 /* forward declaration of special GetInfo functions */
265 CK_RV FC_GetInfoV2(CK_INFO_PTR pInfo);
266 CK_RV NSC_GetInfoV2(CK_INFO_PTR pInfo);
267 CK_RV FC_GetMechanismInfoV2(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
268 CK_MECHANISM_INFO_PTR pInfo);
269 CK_RV NSC_GetMechanismInfoV2(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
270 CK_MECHANISM_INFO_PTR pInfo);
271
272 static CK_FUNCTION_LIST sftk_fipsTable_v2 = {
273 { 2, 40 },
274
275 #undef CK_PKCS11_3_0
276 #define CK_PKCS11_2_0_ONLY 1
277 #undef CK_NEED_ARG_LIST
278 #undef CK_PKCS11_FUNCTION_INFO
279 #define C_GetInfo C_GetInfoV2
280 #define C_GetMechanismInfo C_GetMechanismInfoV2
281
282 #define CK_PKCS11_FUNCTION_INFO(name) \
283 __PASTE(F, name) \
284 ,
285
286 #include "pkcs11f.h"
287
288 };
289
290 #undef C_GetInfo
291 #undef C_GetMechanismInfo
292 #undef CK_NEED_ARG_LIST
293 #undef CK_PKCS11_FUNCTION_INFO
294 #undef CK_PKCS11_2_0_ONLY
295
296 #undef __PASTE
297
298 /*
299 * Array is orderd by default first
300 */
301 static CK_INTERFACE fips_interfaces[] = {
302 { (CK_UTF8CHAR_PTR) "PKCS 11", &sftk_fipsTable, NSS_INTERFACE_FLAGS },
303 { (CK_UTF8CHAR_PTR) "PKCS 11", &sftk_fipsTable_v2, NSS_INTERFACE_FLAGS },
304 { (CK_UTF8CHAR_PTR) "Vendor NSS Module Interface", &sftk_module_funcList, NSS_INTERFACE_FLAGS },
305 { (CK_UTF8CHAR_PTR) "Vendor NSS FIPS Interface", &sftk_fips_funcList, NSS_INTERFACE_FLAGS }
306 };
307 /* must match the count of interfaces in fips_interfaces above*/
308 #define FIPS_INTERFACE_COUNT 4
309
310 /* CKO_NOT_A_KEY can be any object class that's not a key object. */
311 #define CKO_NOT_A_KEY CKO_DATA
312
313 #define SFTK_IS_KEY_OBJECT(objClass) \
314 (((objClass) == CKO_PUBLIC_KEY) || \
315 ((objClass) == CKO_PRIVATE_KEY) || \
316 ((objClass) == CKO_SECRET_KEY))
317
318 #define SFTK_IS_NONPUBLIC_KEY_OBJECT(objClass) \
319 (((objClass) == CKO_PRIVATE_KEY) || ((objClass) == CKO_SECRET_KEY))
320
321 static CK_RV
sftk_get_object_class_and_fipsCheck(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_OBJECT_CLASS * pObjClass)322 sftk_get_object_class_and_fipsCheck(CK_SESSION_HANDLE hSession,
323 CK_OBJECT_HANDLE hObject, CK_OBJECT_CLASS *pObjClass)
324 {
325 CK_RV rv;
326 CK_ATTRIBUTE class;
327 class.type = CKA_CLASS;
328 class.pValue = pObjClass;
329 class.ulValueLen = sizeof(*pObjClass);
330 rv = NSC_GetAttributeValue(hSession, hObject, &class, 1);
331 if ((rv == CKR_OK) && SFTK_IS_NONPUBLIC_KEY_OBJECT(*pObjClass)) {
332 rv = sftk_fipsCheck();
333 }
334 return rv;
335 }
336
337 #ifdef LINUX
338
339 int
sftk_mapLinuxAuditType(NSSAuditSeverity severity,NSSAuditType auditType)340 sftk_mapLinuxAuditType(NSSAuditSeverity severity, NSSAuditType auditType)
341 {
342 switch (auditType) {
343 case NSS_AUDIT_ACCESS_KEY:
344 case NSS_AUDIT_CHANGE_KEY:
345 case NSS_AUDIT_COPY_KEY:
346 case NSS_AUDIT_DERIVE_KEY:
347 case NSS_AUDIT_DESTROY_KEY:
348 case NSS_AUDIT_DIGEST_KEY:
349 case NSS_AUDIT_GENERATE_KEY:
350 case NSS_AUDIT_LOAD_KEY:
351 case NSS_AUDIT_UNWRAP_KEY:
352 case NSS_AUDIT_WRAP_KEY:
353 return AUDIT_CRYPTO_KEY_USER;
354 case NSS_AUDIT_CRYPT:
355 return (severity == NSS_AUDIT_ERROR) ? AUDIT_CRYPTO_FAILURE_USER : AUDIT_CRYPTO_KEY_USER;
356 case NSS_AUDIT_FIPS_STATE:
357 case NSS_AUDIT_INIT_PIN:
358 case NSS_AUDIT_INIT_TOKEN:
359 case NSS_AUDIT_SET_PIN:
360 return AUDIT_CRYPTO_PARAM_CHANGE_USER;
361 case NSS_AUDIT_SELF_TEST:
362 return AUDIT_CRYPTO_TEST_USER;
363 case NSS_AUDIT_LOGIN:
364 return AUDIT_CRYPTO_LOGIN;
365 case NSS_AUDIT_LOGOUT:
366 return AUDIT_CRYPTO_LOGOUT;
367 /* we skip the fault case here so we can get compiler
368 * warnings if new 'NSSAuditType's are added without
369 * added them to this list, defaults fall through */
370 }
371 /* default */
372 return AUDIT_CRYPTO_PARAM_CHANGE_USER;
373 }
374 #endif
375
376 /**********************************************************************
377 *
378 * FIPS 140 auditable event logging
379 *
380 **********************************************************************/
381
382 PRBool sftk_audit_enabled = PR_FALSE;
383
384 /*
385 * Each audit record must have the following information:
386 * - Date and time of the event
387 * - Type of event
388 * - user (subject) identity
389 * - outcome (success or failure) of the event
390 * - process ID
391 * - name (ID) of the object
392 * - for changes to data (except for authentication data and CSPs), the new
393 * and old values of the data
394 * - for authentication attempts, the origin of the attempt (e.g., terminal
395 * identifier)
396 * - for assuming a role, the type of role, and the location of the request
397 */
398 void
sftk_LogAuditMessage(NSSAuditSeverity severity,NSSAuditType auditType,const char * msg)399 sftk_LogAuditMessage(NSSAuditSeverity severity, NSSAuditType auditType,
400 const char *msg)
401 {
402 #ifdef NSS_AUDIT_WITH_SYSLOG
403 int level;
404
405 switch (severity) {
406 case NSS_AUDIT_ERROR:
407 level = LOG_ERR;
408 break;
409 case NSS_AUDIT_WARNING:
410 level = LOG_WARNING;
411 break;
412 default:
413 level = LOG_INFO;
414 break;
415 }
416 /* timestamp is provided by syslog in the message header */
417 syslog(level | LOG_USER /* facility */,
418 "NSS " SOFTOKEN_LIB_NAME "[pid=%d uid=%d]: %s",
419 (int)getpid(), (int)getuid(), msg);
420 #ifdef LINUX
421 if (pthread_once(&libaudit_once_control, libaudit_init) != 0) {
422 return;
423 }
424 if (libaudit_handle) {
425 int audit_fd;
426 int linuxAuditType;
427 int result = (severity != NSS_AUDIT_ERROR); /* 1=success; 0=failed */
428 char *message = PR_smprintf("NSS " SOFTOKEN_LIB_NAME ": %s", msg);
429 if (!message) {
430 return;
431 }
432 audit_fd = audit_open_func();
433 if (audit_fd < 0) {
434 PR_smprintf_free(message);
435 return;
436 }
437 linuxAuditType = sftk_mapLinuxAuditType(severity, auditType);
438 if (audit_log_user_message_func) {
439 audit_log_user_message_func(audit_fd, linuxAuditType, message,
440 NULL, NULL, NULL, result);
441 } else {
442 audit_send_user_message_func(audit_fd, linuxAuditType, message);
443 }
444 audit_close_func(audit_fd);
445 PR_smprintf_free(message);
446 }
447 #endif /* LINUX */
448 #else
449 /* do nothing */
450 #endif
451 }
452
453 /**********************************************************************
454 *
455 * Start of PKCS 11 functions
456 *
457 **********************************************************************/
458 /* return the function list */
459 CK_RV
FC_GetFunctionList(CK_FUNCTION_LIST_PTR * pFunctionList)460 FC_GetFunctionList(CK_FUNCTION_LIST_PTR *pFunctionList)
461 {
462
463 CHECK_FORK();
464
465 *pFunctionList = &sftk_fipsTable_v2;
466 return CKR_OK;
467 }
468
469 CK_RV
FC_GetInterfaceList(CK_INTERFACE_PTR interfaces,CK_ULONG_PTR pulCount)470 FC_GetInterfaceList(CK_INTERFACE_PTR interfaces, CK_ULONG_PTR pulCount)
471 {
472 CK_ULONG count = *pulCount;
473 *pulCount = FIPS_INTERFACE_COUNT;
474 if (interfaces == NULL) {
475 return CKR_OK;
476 }
477 if (count < FIPS_INTERFACE_COUNT) {
478 return CKR_BUFFER_TOO_SMALL;
479 }
480 PORT_Memcpy(interfaces, fips_interfaces, sizeof(fips_interfaces));
481 return CKR_OK;
482 }
483
484 /*
485 * Get the requested interface, use the fips_interfaces array so we can
486 * easily add new interfaces as they occur.
487 */
488 CK_RV
FC_GetInterface(CK_UTF8CHAR_PTR pInterfaceName,CK_VERSION_PTR pVersion,CK_INTERFACE_PTR_PTR ppInterface,CK_FLAGS flags)489 FC_GetInterface(CK_UTF8CHAR_PTR pInterfaceName, CK_VERSION_PTR pVersion,
490 CK_INTERFACE_PTR_PTR ppInterface, CK_FLAGS flags)
491 {
492 int i;
493 for (i = 0; i < FIPS_INTERFACE_COUNT; i++) {
494 CK_INTERFACE_PTR interface = &fips_interfaces[i];
495 if (pInterfaceName && PORT_Strcmp((char *)pInterfaceName, (char *)interface->pInterfaceName) != 0) {
496 continue;
497 }
498 if (pVersion && PORT_Memcmp(pVersion, (CK_VERSION *)interface->pFunctionList, sizeof(CK_VERSION)) != 0) {
499 continue;
500 }
501 if (flags & ((interface->flags & flags) != flags)) {
502 continue;
503 }
504 *ppInterface = interface;
505 return CKR_OK;
506 }
507 return CKR_ARGUMENTS_BAD;
508 }
509
510 /* sigh global so pkcs11 can read it */
511 PRBool nsf_init = PR_FALSE;
512
513 void
fc_log_init_error(CK_RV crv)514 fc_log_init_error(CK_RV crv)
515 {
516 if (sftk_audit_enabled) {
517 char msg[128];
518 PR_snprintf(msg, sizeof msg,
519 "C_Initialize()=0x%08lX "
520 "power-up self-tests failed",
521 (PRUint32)crv);
522 sftk_LogAuditMessage(NSS_AUDIT_ERROR, NSS_AUDIT_SELF_TEST, msg);
523 }
524 }
525
526 /* FC_Initialize initializes the PKCS #11 library. */
527 CK_RV
FC_Initialize(CK_VOID_PTR pReserved)528 FC_Initialize(CK_VOID_PTR pReserved)
529 {
530 const char *envp;
531 CK_RV crv;
532
533 if ((envp = PR_GetEnv("NSS_ENABLE_AUDIT")) != NULL) {
534 sftk_audit_enabled = (atoi(envp) == 1);
535 }
536
537 /* At this point we should have already done post and integrity checks.
538 * if we haven't, it probably means the FIPS product has not been installed
539 * or the tests failed. Don't let an application try to enter FIPS mode */
540 crv = sftk_FIPSEntryOK();
541 if (crv != CKR_OK) {
542 sftk_fatalError = PR_TRUE;
543 fc_log_init_error(crv);
544 return crv;
545 }
546
547 sftk_ForkReset(pReserved, &crv);
548
549 if (nsf_init) {
550 return CKR_CRYPTOKI_ALREADY_INITIALIZED;
551 }
552
553 crv = nsc_CommonInitialize(pReserved, PR_TRUE);
554
555 /* not an 'else' rv can be set by either SFTK_LowInit or SFTK_SlotInit*/
556 if (crv != CKR_OK) {
557 sftk_fatalError = PR_TRUE;
558 return crv;
559 }
560
561 sftk_fatalError = PR_FALSE; /* any error has been reset */
562 nsf_init = PR_TRUE;
563 isLevel2 = PR_TRUE; /* assume level 2 unless we learn otherwise */
564
565 return CKR_OK;
566 }
567
568 /*FC_Finalize indicates that an application is done with the PKCS #11 library.*/
569 CK_RV
FC_Finalize(CK_VOID_PTR pReserved)570 FC_Finalize(CK_VOID_PTR pReserved)
571 {
572 CK_RV crv;
573
574 if (sftk_ForkReset(pReserved, &crv)) {
575 return crv;
576 }
577
578 if (!nsf_init) {
579 return CKR_OK;
580 }
581
582 crv = nsc_CommonFinalize(pReserved, PR_TRUE);
583
584 nsf_init = (PRBool) !(crv == CKR_OK);
585 return crv;
586 }
587
588 /* FC_GetInfo returns general information about PKCS #11. */
589 CK_RV
FC_GetInfo(CK_INFO_PTR pInfo)590 FC_GetInfo(CK_INFO_PTR pInfo)
591 {
592 CHECK_FORK();
593
594 return NSC_GetInfo(pInfo);
595 }
596
597 /* FC_GetInfo returns general information about PKCS #11. */
598 CK_RV
FC_GetInfoV2(CK_INFO_PTR pInfo)599 FC_GetInfoV2(CK_INFO_PTR pInfo)
600 {
601 CHECK_FORK();
602
603 return NSC_GetInfoV2(pInfo);
604 }
605
606 /* FC_GetSlotList obtains a list of slots in the system. */
607 CK_RV
FC_GetSlotList(CK_BBOOL tokenPresent,CK_SLOT_ID_PTR pSlotList,CK_ULONG_PTR pulCount)608 FC_GetSlotList(CK_BBOOL tokenPresent,
609 CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount)
610 {
611 CHECK_FORK();
612
613 return nsc_CommonGetSlotList(tokenPresent, pSlotList, pulCount,
614 NSC_FIPS_MODULE);
615 }
616
617 /* FC_GetSlotInfo obtains information about a particular slot in the system. */
618 CK_RV
FC_GetSlotInfo(CK_SLOT_ID slotID,CK_SLOT_INFO_PTR pInfo)619 FC_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo)
620 {
621 CHECK_FORK();
622
623 return NSC_GetSlotInfo(slotID, pInfo);
624 }
625
626 /*FC_GetTokenInfo obtains information about a particular token in the system.*/
627 CK_RV
FC_GetTokenInfo(CK_SLOT_ID slotID,CK_TOKEN_INFO_PTR pInfo)628 FC_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo)
629 {
630 CK_RV crv;
631
632 CHECK_FORK();
633
634 crv = NSC_GetTokenInfo(slotID, pInfo);
635 if (crv == CKR_OK) {
636 /* use the global database to figure out if we are running in
637 * FIPS 140 Level 1 or Level 2 */
638 if (slotID == FIPS_SLOT_ID &&
639 (pInfo->flags & CKF_LOGIN_REQUIRED) == 0) {
640 isLevel2 = PR_FALSE;
641 }
642 }
643 return crv;
644 }
645
646 /*FC_GetMechanismList obtains a list of mechanism types supported by a token.*/
647 CK_RV
FC_GetMechanismList(CK_SLOT_ID slotID,CK_MECHANISM_TYPE_PTR pMechanismList,CK_ULONG_PTR pusCount)648 FC_GetMechanismList(CK_SLOT_ID slotID,
649 CK_MECHANISM_TYPE_PTR pMechanismList, CK_ULONG_PTR pusCount)
650 {
651 CHECK_FORK();
652
653 SFTK_FIPSFATALCHECK();
654 if (sftk_isFIPS(slotID)) {
655 slotID = NETSCAPE_SLOT_ID;
656 }
657 /* FIPS Slots support all functions */
658 return NSC_GetMechanismList(slotID, pMechanismList, pusCount);
659 }
660
661 /* FC_GetMechanismInfo obtains information about a particular mechanism
662 * possibly supported by a token. */
663 CK_RV
FC_GetMechanismInfo(CK_SLOT_ID slotID,CK_MECHANISM_TYPE type,CK_MECHANISM_INFO_PTR pInfo)664 FC_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
665 CK_MECHANISM_INFO_PTR pInfo)
666 {
667 CHECK_FORK();
668
669 SFTK_FIPSFATALCHECK();
670 if (sftk_isFIPS(slotID)) {
671 slotID = NETSCAPE_SLOT_ID;
672 }
673 /* FIPS Slots support all functions */
674 return NSC_GetMechanismInfo(slotID, type, pInfo);
675 }
676
677 /* FC_GetMechanismInfoV2 same as FC_GetMechanismInfo except the Message
678 * flags have been stripped out */
679 CK_RV
FC_GetMechanismInfoV2(CK_SLOT_ID slotID,CK_MECHANISM_TYPE type,CK_MECHANISM_INFO_PTR pInfo)680 FC_GetMechanismInfoV2(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
681 CK_MECHANISM_INFO_PTR pInfo)
682 {
683 CHECK_FORK();
684
685 SFTK_FIPSFATALCHECK();
686 if (sftk_isFIPS(slotID)) {
687 slotID = NETSCAPE_SLOT_ID;
688 }
689 /* FIPS Slots support all functions */
690 return NSC_GetMechanismInfoV2(slotID, type, pInfo);
691 }
692
693 /* FC_InitToken initializes a token. */
694 CK_RV
FC_InitToken(CK_SLOT_ID slotID,CK_CHAR_PTR pPin,CK_ULONG usPinLen,CK_CHAR_PTR pLabel)695 FC_InitToken(CK_SLOT_ID slotID, CK_CHAR_PTR pPin,
696 CK_ULONG usPinLen, CK_CHAR_PTR pLabel)
697 {
698 CK_RV crv;
699
700 CHECK_FORK();
701
702 crv = NSC_InitToken(slotID, pPin, usPinLen, pLabel);
703 if (sftk_audit_enabled) {
704 char msg[128];
705 NSSAuditSeverity severity = (crv == CKR_OK) ? NSS_AUDIT_INFO : NSS_AUDIT_ERROR;
706 /* pLabel points to a 32-byte label, which is not null-terminated */
707 PR_snprintf(msg, sizeof msg,
708 "C_InitToken(slotID=%lu, pLabel=\"%.32s\")=0x%08lX",
709 (PRUint32)slotID, pLabel, (PRUint32)crv);
710 sftk_LogAuditMessage(severity, NSS_AUDIT_INIT_TOKEN, msg);
711 }
712 return crv;
713 }
714
715 /* FC_InitPIN initializes the normal user's PIN. */
716 CK_RV
FC_InitPIN(CK_SESSION_HANDLE hSession,CK_CHAR_PTR pPin,CK_ULONG ulPinLen)717 FC_InitPIN(CK_SESSION_HANDLE hSession,
718 CK_CHAR_PTR pPin, CK_ULONG ulPinLen)
719 {
720 CK_RV rv;
721
722 CHECK_FORK();
723
724 if (sftk_fatalError)
725 return CKR_DEVICE_ERROR;
726 /* NSC_InitPIN will only work once per database. We can either initialize
727 * it to level1 (pin len == 0) or level2. If we initialize to level 2, then
728 * we need to make sure the pin meets FIPS requirements */
729 if ((ulPinLen == 0) || ((rv = sftk_newPinCheck(pPin, ulPinLen)) == CKR_OK)) {
730 rv = NSC_InitPIN(hSession, pPin, ulPinLen);
731 if ((rv == CKR_OK) &&
732 (sftk_SlotIDFromSessionHandle(hSession) == FIPS_SLOT_ID)) {
733 isLevel2 = (ulPinLen > 0) ? PR_TRUE : PR_FALSE;
734 }
735 }
736 if (sftk_audit_enabled) {
737 char msg[128];
738 NSSAuditSeverity severity = (rv == CKR_OK) ? NSS_AUDIT_INFO : NSS_AUDIT_ERROR;
739 PR_snprintf(msg, sizeof msg,
740 "C_InitPIN(hSession=0x%08lX)=0x%08lX",
741 (PRUint32)hSession, (PRUint32)rv);
742 sftk_LogAuditMessage(severity, NSS_AUDIT_INIT_PIN, msg);
743 }
744 return rv;
745 }
746
747 /* FC_SetPIN modifies the PIN of user that is currently logged in. */
748 /* NOTE: This is only valid for the PRIVATE_KEY_SLOT */
749 CK_RV
FC_SetPIN(CK_SESSION_HANDLE hSession,CK_CHAR_PTR pOldPin,CK_ULONG usOldLen,CK_CHAR_PTR pNewPin,CK_ULONG usNewLen)750 FC_SetPIN(CK_SESSION_HANDLE hSession, CK_CHAR_PTR pOldPin,
751 CK_ULONG usOldLen, CK_CHAR_PTR pNewPin, CK_ULONG usNewLen)
752 {
753 CK_RV rv;
754
755 CHECK_FORK();
756
757 rv = sftk_fipsCheck();
758 if (rv != CKR_OK) {
759 goto loser;
760 }
761
762 if (isLevel2 || usNewLen > 0) {
763 rv = sftk_newPinCheck(pNewPin, usNewLen);
764 if (rv != CKR_OK) {
765 goto loser;
766 }
767 rv = NSC_SetPIN(hSession, pOldPin, usOldLen, pNewPin, usNewLen);
768 if (rv != CKR_OK) {
769 goto loser;
770 }
771 if (sftk_SlotIDFromSessionHandle(hSession) == FIPS_SLOT_ID) {
772 /* if we set the password in level1 we now go
773 * to level2. NOTE: we don't allow the user to
774 * go from level2 to level1 */
775 isLevel2 = PR_TRUE;
776 }
777 } else {
778 /* here both old and new passwords are empty, but we need to
779 * call NSC_SetPIN to force rekey the database entries */
780 PORT_Assert(usNewLen == 0);
781 rv = NSC_SetPIN(hSession, pOldPin, usOldLen, pNewPin, usNewLen);
782 if (rv != CKR_OK) {
783 goto loser;
784 }
785 }
786
787 loser:
788 if (sftk_audit_enabled) {
789 char msg[128];
790 NSSAuditSeverity severity = (rv == CKR_OK) ? NSS_AUDIT_INFO : NSS_AUDIT_ERROR;
791 PR_snprintf(msg, sizeof msg,
792 "C_SetPIN(hSession=0x%08lX)=0x%08lX",
793 (PRUint32)hSession, (PRUint32)rv);
794 sftk_LogAuditMessage(severity, NSS_AUDIT_SET_PIN, msg);
795 }
796 return rv;
797 }
798
799 /* FC_OpenSession opens a session between an application and a token. */
800 CK_RV
FC_OpenSession(CK_SLOT_ID slotID,CK_FLAGS flags,CK_VOID_PTR pApplication,CK_NOTIFY Notify,CK_SESSION_HANDLE_PTR phSession)801 FC_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags,
802 CK_VOID_PTR pApplication, CK_NOTIFY Notify, CK_SESSION_HANDLE_PTR phSession)
803 {
804 SFTK_FIPSFATALCHECK();
805
806 CHECK_FORK();
807
808 return NSC_OpenSession(slotID, flags, pApplication, Notify, phSession);
809 }
810
811 /* FC_CloseSession closes a session between an application and a token. */
812 CK_RV
FC_CloseSession(CK_SESSION_HANDLE hSession)813 FC_CloseSession(CK_SESSION_HANDLE hSession)
814 {
815 CHECK_FORK();
816
817 return NSC_CloseSession(hSession);
818 }
819
820 /* FC_CloseAllSessions closes all sessions with a token. */
821 CK_RV
FC_CloseAllSessions(CK_SLOT_ID slotID)822 FC_CloseAllSessions(CK_SLOT_ID slotID)
823 {
824
825 CHECK_FORK();
826
827 return NSC_CloseAllSessions(slotID);
828 }
829
830 CK_RV
FC_SessionCancel(CK_SESSION_HANDLE hSession,CK_FLAGS flags)831 FC_SessionCancel(CK_SESSION_HANDLE hSession, CK_FLAGS flags)
832 {
833 SFTK_FIPSFATALCHECK();
834
835 CHECK_FORK();
836
837 return NSC_SessionCancel(hSession, flags);
838 }
839
840 /* FC_GetSessionInfo obtains information about the session. */
841 CK_RV
FC_GetSessionInfo(CK_SESSION_HANDLE hSession,CK_SESSION_INFO_PTR pInfo)842 FC_GetSessionInfo(CK_SESSION_HANDLE hSession,
843 CK_SESSION_INFO_PTR pInfo)
844 {
845 CK_RV rv;
846 SFTK_FIPSFATALCHECK();
847
848 CHECK_FORK();
849
850 rv = NSC_GetSessionInfo(hSession, pInfo);
851 if (rv == CKR_OK) {
852 /* handle the case where the auxilary slot doesn't require login.
853 * piggy back on the main token's login state */
854 if (isLoggedIn &&
855 ((pInfo->state == CKS_RO_PUBLIC_SESSION) ||
856 (pInfo->state == CKS_RW_PUBLIC_SESSION))) {
857 CK_RV crv;
858 CK_TOKEN_INFO tInfo;
859 crv = NSC_GetTokenInfo(sftk_SlotIDFromSessionHandle(hSession),
860 &tInfo);
861 /* if the token doesn't login, use our global login state */
862 if ((crv == CKR_OK) && ((tInfo.flags & CKF_LOGIN_REQUIRED) == 0)) {
863 if (pInfo->state == CKS_RO_PUBLIC_SESSION) {
864 pInfo->state = CKS_RO_USER_FUNCTIONS;
865 } else {
866 pInfo->state = CKS_RW_USER_FUNCTIONS;
867 }
868 }
869 }
870 }
871 return rv;
872 }
873
874 /* FC_Login logs a user into a token. */
875 CK_RV
FC_Login(CK_SESSION_HANDLE hSession,CK_USER_TYPE userType,CK_CHAR_PTR pPin,CK_ULONG usPinLen)876 FC_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
877 CK_CHAR_PTR pPin, CK_ULONG usPinLen)
878 {
879 CK_RV rv;
880 PRBool successful;
881 if (sftk_fatalError)
882 return CKR_DEVICE_ERROR;
883 rv = NSC_Login(hSession, userType, pPin, usPinLen);
884 successful = (rv == CKR_OK) || (rv == CKR_USER_ALREADY_LOGGED_IN);
885 if (successful)
886 isLoggedIn = PR_TRUE;
887 if (sftk_audit_enabled) {
888 char msg[128];
889 NSSAuditSeverity severity;
890 severity = successful ? NSS_AUDIT_INFO : NSS_AUDIT_ERROR;
891 PR_snprintf(msg, sizeof msg,
892 "C_Login(hSession=0x%08lX, userType=%lu)=0x%08lX",
893 (PRUint32)hSession, (PRUint32)userType, (PRUint32)rv);
894 sftk_LogAuditMessage(severity, NSS_AUDIT_LOGIN, msg);
895 }
896 return rv;
897 }
898
899 CK_RV
FC_LoginUser(CK_SESSION_HANDLE hSession,CK_USER_TYPE userType,CK_CHAR_PTR pPin,CK_ULONG ulPinLen,CK_UTF8CHAR_PTR pUsername,CK_ULONG ulUsernameLen)900 FC_LoginUser(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
901 CK_CHAR_PTR pPin, CK_ULONG ulPinLen, CK_UTF8CHAR_PTR pUsername,
902 CK_ULONG ulUsernameLen)
903 {
904 CK_RV rv;
905 PRBool successful;
906 if (sftk_fatalError)
907 return CKR_DEVICE_ERROR;
908 rv = NSC_LoginUser(hSession, userType, pPin, ulPinLen,
909 pUsername, ulUsernameLen);
910 successful = (rv == CKR_OK) || (rv == CKR_USER_ALREADY_LOGGED_IN);
911 if (successful)
912 isLoggedIn = PR_TRUE;
913 if (sftk_audit_enabled) {
914 char msg[128];
915 char user[61];
916 int len = PR_MIN(ulUsernameLen, sizeof(user) - 1);
917 PORT_Memcpy(user, pUsername, len);
918 user[len] = 0;
919 NSSAuditSeverity severity;
920 severity = successful ? NSS_AUDIT_INFO : NSS_AUDIT_ERROR;
921 PR_snprintf(msg, sizeof msg,
922 "C_LoginUser(hSession=0x%08lX, userType=%lu username=%s)=0x%08lX",
923 (PRUint32)hSession, (PRUint32)userType, user, (PRUint32)rv);
924 sftk_LogAuditMessage(severity, NSS_AUDIT_LOGIN, msg);
925 }
926 return rv;
927 }
928
929 /* FC_Logout logs a user out from a token. */
930 CK_RV
FC_Logout(CK_SESSION_HANDLE hSession)931 FC_Logout(CK_SESSION_HANDLE hSession)
932 {
933 CK_RV rv;
934
935 CHECK_FORK();
936
937 if ((rv = sftk_fipsCheck()) == CKR_OK) {
938 rv = NSC_Logout(hSession);
939 isLoggedIn = PR_FALSE;
940 }
941 if (sftk_audit_enabled) {
942 char msg[128];
943 NSSAuditSeverity severity = (rv == CKR_OK) ? NSS_AUDIT_INFO : NSS_AUDIT_ERROR;
944 PR_snprintf(msg, sizeof msg,
945 "C_Logout(hSession=0x%08lX)=0x%08lX",
946 (PRUint32)hSession, (PRUint32)rv);
947 sftk_LogAuditMessage(severity, NSS_AUDIT_LOGOUT, msg);
948 }
949 return rv;
950 }
951
952 /* FC_CreateObject creates a new object. */
953 CK_RV
FC_CreateObject(CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phObject)954 FC_CreateObject(CK_SESSION_HANDLE hSession,
955 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
956 CK_OBJECT_HANDLE_PTR phObject)
957 {
958 CK_OBJECT_CLASS *classptr;
959 CK_RV rv = CKR_OK;
960
961 CHECK_FORK();
962
963 classptr = (CK_OBJECT_CLASS *)fc_getAttribute(pTemplate, ulCount, CKA_CLASS);
964 if (classptr == NULL)
965 return CKR_TEMPLATE_INCOMPLETE;
966
967 if (*classptr == CKO_NSS_NEWSLOT || *classptr == CKO_NSS_DELSLOT) {
968 if (sftk_fatalError)
969 return CKR_DEVICE_ERROR;
970 } else {
971 rv = sftk_fipsCheck();
972 if (rv != CKR_OK)
973 return rv;
974 }
975
976 /* FIPS can't create keys from raw key material */
977 if (SFTK_IS_NONPUBLIC_KEY_OBJECT(*classptr)) {
978 rv = CKR_ATTRIBUTE_VALUE_INVALID;
979 } else {
980 rv = NSC_CreateObject(hSession, pTemplate, ulCount, phObject);
981 }
982 if (sftk_audit_enabled && SFTK_IS_KEY_OBJECT(*classptr)) {
983 sftk_AuditCreateObject(hSession, pTemplate, ulCount, phObject, rv);
984 }
985 return rv;
986 }
987
988 /* FC_CopyObject copies an object, creating a new object for the copy. */
989 CK_RV
FC_CopyObject(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phNewObject)990 FC_CopyObject(CK_SESSION_HANDLE hSession,
991 CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
992 CK_OBJECT_HANDLE_PTR phNewObject)
993 {
994 CK_RV rv;
995 CK_OBJECT_CLASS objClass = CKO_NOT_A_KEY;
996
997 CHECK_FORK();
998
999 SFTK_FIPSFATALCHECK();
1000 rv = sftk_get_object_class_and_fipsCheck(hSession, hObject, &objClass);
1001 if (rv == CKR_OK) {
1002 rv = NSC_CopyObject(hSession, hObject, pTemplate, ulCount, phNewObject);
1003 }
1004 if (sftk_audit_enabled && SFTK_IS_KEY_OBJECT(objClass)) {
1005 sftk_AuditCopyObject(hSession,
1006 hObject, pTemplate, ulCount, phNewObject, rv);
1007 }
1008 return rv;
1009 }
1010
1011 /* FC_DestroyObject destroys an object. */
1012 CK_RV
FC_DestroyObject(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject)1013 FC_DestroyObject(CK_SESSION_HANDLE hSession,
1014 CK_OBJECT_HANDLE hObject)
1015 {
1016 CK_RV rv;
1017 CK_OBJECT_CLASS objClass = CKO_NOT_A_KEY;
1018
1019 CHECK_FORK();
1020
1021 SFTK_FIPSFATALCHECK();
1022 rv = sftk_get_object_class_and_fipsCheck(hSession, hObject, &objClass);
1023 if (rv == CKR_OK) {
1024 rv = NSC_DestroyObject(hSession, hObject);
1025 }
1026 if (sftk_audit_enabled && SFTK_IS_KEY_OBJECT(objClass)) {
1027 sftk_AuditDestroyObject(hSession, hObject, rv);
1028 }
1029 return rv;
1030 }
1031
1032 /* FC_GetObjectSize gets the size of an object in bytes. */
1033 CK_RV
FC_GetObjectSize(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ULONG_PTR pulSize)1034 FC_GetObjectSize(CK_SESSION_HANDLE hSession,
1035 CK_OBJECT_HANDLE hObject, CK_ULONG_PTR pulSize)
1036 {
1037 CK_RV rv;
1038 CK_OBJECT_CLASS objClass = CKO_NOT_A_KEY;
1039
1040 CHECK_FORK();
1041
1042 SFTK_FIPSFATALCHECK();
1043 rv = sftk_get_object_class_and_fipsCheck(hSession, hObject, &objClass);
1044 if (rv == CKR_OK) {
1045 rv = NSC_GetObjectSize(hSession, hObject, pulSize);
1046 }
1047 if (sftk_audit_enabled && SFTK_IS_KEY_OBJECT(objClass)) {
1048 sftk_AuditGetObjectSize(hSession, hObject, pulSize, rv);
1049 }
1050 return rv;
1051 }
1052
1053 /* FC_GetAttributeValue obtains the value of one or more object attributes. */
1054 CK_RV
FC_GetAttributeValue(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)1055 FC_GetAttributeValue(CK_SESSION_HANDLE hSession,
1056 CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
1057 {
1058 CK_RV rv;
1059 CK_OBJECT_CLASS objClass = CKO_NOT_A_KEY;
1060
1061 CHECK_FORK();
1062
1063 SFTK_FIPSFATALCHECK();
1064 rv = sftk_get_object_class_and_fipsCheck(hSession, hObject, &objClass);
1065 if (rv == CKR_OK) {
1066 rv = NSC_GetAttributeValue(hSession, hObject, pTemplate, ulCount);
1067 }
1068 if (sftk_audit_enabled && SFTK_IS_KEY_OBJECT(objClass)) {
1069 sftk_AuditGetAttributeValue(hSession, hObject, pTemplate, ulCount, rv);
1070 }
1071 return rv;
1072 }
1073
1074 /* FC_SetAttributeValue modifies the value of one or more object attributes */
1075 CK_RV
FC_SetAttributeValue(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)1076 FC_SetAttributeValue(CK_SESSION_HANDLE hSession,
1077 CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
1078 {
1079 CK_RV rv;
1080 CK_OBJECT_CLASS objClass = CKO_NOT_A_KEY;
1081
1082 CHECK_FORK();
1083
1084 SFTK_FIPSFATALCHECK();
1085 rv = sftk_get_object_class_and_fipsCheck(hSession, hObject, &objClass);
1086 if (rv == CKR_OK) {
1087 rv = NSC_SetAttributeValue(hSession, hObject, pTemplate, ulCount);
1088 }
1089 if (sftk_audit_enabled && SFTK_IS_KEY_OBJECT(objClass)) {
1090 sftk_AuditSetAttributeValue(hSession, hObject, pTemplate, ulCount, rv);
1091 }
1092 return rv;
1093 }
1094
1095 /* FC_FindObjectsInit initializes a search for token and session objects
1096 * that match a template. */
1097 CK_RV
FC_FindObjectsInit(CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG usCount)1098 FC_FindObjectsInit(CK_SESSION_HANDLE hSession,
1099 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG usCount)
1100 {
1101 /* let publically readable object be found */
1102 unsigned int i;
1103 CK_RV rv;
1104 PRBool needLogin = PR_FALSE;
1105
1106 CHECK_FORK();
1107
1108 SFTK_FIPSFATALCHECK();
1109
1110 for (i = 0; i < usCount; i++) {
1111 CK_OBJECT_CLASS class;
1112 if (pTemplate[i].type != CKA_CLASS) {
1113 continue;
1114 }
1115 if (pTemplate[i].ulValueLen != sizeof(CK_OBJECT_CLASS)) {
1116 continue;
1117 }
1118 if (pTemplate[i].pValue == NULL) {
1119 continue;
1120 }
1121 class = *(CK_OBJECT_CLASS *)pTemplate[i].pValue;
1122 if ((class == CKO_PRIVATE_KEY) || (class == CKO_SECRET_KEY)) {
1123 needLogin = PR_TRUE;
1124 break;
1125 }
1126 }
1127 if (needLogin) {
1128 if ((rv = sftk_fipsCheck()) != CKR_OK)
1129 return rv;
1130 }
1131 return NSC_FindObjectsInit(hSession, pTemplate, usCount);
1132 }
1133
1134 /* FC_FindObjects continues a search for token and session objects
1135 * that match a template, obtaining additional object handles. */
1136 CK_RV
FC_FindObjects(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE_PTR phObject,CK_ULONG usMaxObjectCount,CK_ULONG_PTR pusObjectCount)1137 FC_FindObjects(CK_SESSION_HANDLE hSession,
1138 CK_OBJECT_HANDLE_PTR phObject, CK_ULONG usMaxObjectCount,
1139 CK_ULONG_PTR pusObjectCount)
1140 {
1141 CHECK_FORK();
1142
1143 /* let publically readable object be found */
1144 SFTK_FIPSFATALCHECK();
1145 return NSC_FindObjects(hSession, phObject, usMaxObjectCount,
1146 pusObjectCount);
1147 }
1148
1149 /*
1150 ************** Crypto Functions: Encrypt ************************
1151 */
1152
1153 /* FC_EncryptInit initializes an encryption operation. */
1154 CK_RV
FC_EncryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1155 FC_EncryptInit(CK_SESSION_HANDLE hSession,
1156 CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1157 {
1158 SFTK_FIPSCHECK();
1159 CHECK_FORK();
1160
1161 rv = NSC_EncryptInit(hSession, pMechanism, hKey);
1162 if (sftk_audit_enabled) {
1163 sftk_AuditCryptInit("Encrypt", hSession, pMechanism, hKey, rv);
1164 }
1165 return rv;
1166 }
1167
1168 /* FC_Encrypt encrypts single-part data. */
1169 CK_RV
FC_Encrypt(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG usDataLen,CK_BYTE_PTR pEncryptedData,CK_ULONG_PTR pusEncryptedDataLen)1170 FC_Encrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
1171 CK_ULONG usDataLen, CK_BYTE_PTR pEncryptedData,
1172 CK_ULONG_PTR pusEncryptedDataLen)
1173 {
1174 SFTK_FIPSCHECK();
1175 CHECK_FORK();
1176
1177 return NSC_Encrypt(hSession, pData, usDataLen, pEncryptedData,
1178 pusEncryptedDataLen);
1179 }
1180
1181 /* FC_EncryptUpdate continues a multiple-part encryption operation. */
1182 CK_RV
FC_EncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG usPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pusEncryptedPartLen)1183 FC_EncryptUpdate(CK_SESSION_HANDLE hSession,
1184 CK_BYTE_PTR pPart, CK_ULONG usPartLen, CK_BYTE_PTR pEncryptedPart,
1185 CK_ULONG_PTR pusEncryptedPartLen)
1186 {
1187 SFTK_FIPSCHECK();
1188 CHECK_FORK();
1189
1190 return NSC_EncryptUpdate(hSession, pPart, usPartLen, pEncryptedPart,
1191 pusEncryptedPartLen);
1192 }
1193
1194 /* FC_EncryptFinal finishes a multiple-part encryption operation. */
1195 CK_RV
FC_EncryptFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastEncryptedPart,CK_ULONG_PTR pusLastEncryptedPartLen)1196 FC_EncryptFinal(CK_SESSION_HANDLE hSession,
1197 CK_BYTE_PTR pLastEncryptedPart, CK_ULONG_PTR pusLastEncryptedPartLen)
1198 {
1199 SFTK_FIPSCHECK();
1200 CHECK_FORK();
1201
1202 return NSC_EncryptFinal(hSession, pLastEncryptedPart,
1203 pusLastEncryptedPartLen);
1204 }
1205
1206 /*
1207 ************** Crypto Functions: Decrypt ************************
1208 */
1209
1210 /* FC_DecryptInit initializes a decryption operation. */
1211 CK_RV
FC_DecryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1212 FC_DecryptInit(CK_SESSION_HANDLE hSession,
1213 CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1214 {
1215 SFTK_FIPSCHECK();
1216 CHECK_FORK();
1217
1218 rv = NSC_DecryptInit(hSession, pMechanism, hKey);
1219 if (sftk_audit_enabled) {
1220 sftk_AuditCryptInit("Decrypt", hSession, pMechanism, hKey, rv);
1221 }
1222 return rv;
1223 }
1224
1225 /* FC_Decrypt decrypts encrypted data in a single part. */
1226 CK_RV
FC_Decrypt(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedData,CK_ULONG usEncryptedDataLen,CK_BYTE_PTR pData,CK_ULONG_PTR pusDataLen)1227 FC_Decrypt(CK_SESSION_HANDLE hSession,
1228 CK_BYTE_PTR pEncryptedData, CK_ULONG usEncryptedDataLen, CK_BYTE_PTR pData,
1229 CK_ULONG_PTR pusDataLen)
1230 {
1231 SFTK_FIPSCHECK();
1232 CHECK_FORK();
1233
1234 return NSC_Decrypt(hSession, pEncryptedData, usEncryptedDataLen, pData,
1235 pusDataLen);
1236 }
1237
1238 /* FC_DecryptUpdate continues a multiple-part decryption operation. */
1239 CK_RV
FC_DecryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG usEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pusPartLen)1240 FC_DecryptUpdate(CK_SESSION_HANDLE hSession,
1241 CK_BYTE_PTR pEncryptedPart, CK_ULONG usEncryptedPartLen,
1242 CK_BYTE_PTR pPart, CK_ULONG_PTR pusPartLen)
1243 {
1244 SFTK_FIPSCHECK();
1245 CHECK_FORK();
1246
1247 return NSC_DecryptUpdate(hSession, pEncryptedPart, usEncryptedPartLen,
1248 pPart, pusPartLen);
1249 }
1250
1251 /* FC_DecryptFinal finishes a multiple-part decryption operation. */
1252 CK_RV
FC_DecryptFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastPart,CK_ULONG_PTR pusLastPartLen)1253 FC_DecryptFinal(CK_SESSION_HANDLE hSession,
1254 CK_BYTE_PTR pLastPart, CK_ULONG_PTR pusLastPartLen)
1255 {
1256 SFTK_FIPSCHECK();
1257 CHECK_FORK();
1258
1259 return NSC_DecryptFinal(hSession, pLastPart, pusLastPartLen);
1260 }
1261
1262 /*
1263 ************** Crypto Functions: Digest (HASH) ************************
1264 */
1265
1266 /* FC_DigestInit initializes a message-digesting operation. */
1267 CK_RV
FC_DigestInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism)1268 FC_DigestInit(CK_SESSION_HANDLE hSession,
1269 CK_MECHANISM_PTR pMechanism)
1270 {
1271 SFTK_FIPSFATALCHECK();
1272 CHECK_FORK();
1273
1274 return NSC_DigestInit(hSession, pMechanism);
1275 }
1276
1277 /* FC_Digest digests data in a single part. */
1278 CK_RV
FC_Digest(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG usDataLen,CK_BYTE_PTR pDigest,CK_ULONG_PTR pusDigestLen)1279 FC_Digest(CK_SESSION_HANDLE hSession,
1280 CK_BYTE_PTR pData, CK_ULONG usDataLen, CK_BYTE_PTR pDigest,
1281 CK_ULONG_PTR pusDigestLen)
1282 {
1283 SFTK_FIPSFATALCHECK();
1284 CHECK_FORK();
1285
1286 return NSC_Digest(hSession, pData, usDataLen, pDigest, pusDigestLen);
1287 }
1288
1289 /* FC_DigestUpdate continues a multiple-part message-digesting operation. */
1290 CK_RV
FC_DigestUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG usPartLen)1291 FC_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
1292 CK_ULONG usPartLen)
1293 {
1294 SFTK_FIPSFATALCHECK();
1295 CHECK_FORK();
1296
1297 return NSC_DigestUpdate(hSession, pPart, usPartLen);
1298 }
1299
1300 /* FC_DigestFinal finishes a multiple-part message-digesting operation. */
1301 CK_RV
FC_DigestFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pDigest,CK_ULONG_PTR pusDigestLen)1302 FC_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest,
1303 CK_ULONG_PTR pusDigestLen)
1304 {
1305 SFTK_FIPSFATALCHECK();
1306 CHECK_FORK();
1307
1308 return NSC_DigestFinal(hSession, pDigest, pusDigestLen);
1309 }
1310
1311 /*
1312 ************** Crypto Functions: Sign ************************
1313 */
1314
1315 /* FC_SignInit initializes a signature (private key encryption) operation,
1316 * where the signature is (will be) an appendix to the data,
1317 * and plaintext cannot be recovered from the signature */
1318 CK_RV
FC_SignInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1319 FC_SignInit(CK_SESSION_HANDLE hSession,
1320 CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1321 {
1322 SFTK_FIPSCHECK();
1323 CHECK_FORK();
1324
1325 rv = NSC_SignInit(hSession, pMechanism, hKey);
1326 if (sftk_audit_enabled) {
1327 sftk_AuditCryptInit("Sign", hSession, pMechanism, hKey, rv);
1328 }
1329 return rv;
1330 }
1331
1332 /* FC_Sign signs (encrypts with private key) data in a single part,
1333 * where the signature is (will be) an appendix to the data,
1334 * and plaintext cannot be recovered from the signature */
1335 CK_RV
FC_Sign(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG usDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pusSignatureLen)1336 FC_Sign(CK_SESSION_HANDLE hSession,
1337 CK_BYTE_PTR pData, CK_ULONG usDataLen, CK_BYTE_PTR pSignature,
1338 CK_ULONG_PTR pusSignatureLen)
1339 {
1340 SFTK_FIPSCHECK();
1341 CHECK_FORK();
1342
1343 return NSC_Sign(hSession, pData, usDataLen, pSignature, pusSignatureLen);
1344 }
1345
1346 /* FC_SignUpdate continues a multiple-part signature operation,
1347 * where the signature is (will be) an appendix to the data,
1348 * and plaintext cannot be recovered from the signature */
1349 CK_RV
FC_SignUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG usPartLen)1350 FC_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
1351 CK_ULONG usPartLen)
1352 {
1353 SFTK_FIPSCHECK();
1354 CHECK_FORK();
1355
1356 return NSC_SignUpdate(hSession, pPart, usPartLen);
1357 }
1358
1359 /* FC_SignFinal finishes a multiple-part signature operation,
1360 * returning the signature. */
1361 CK_RV
FC_SignFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG_PTR pusSignatureLen)1362 FC_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature,
1363 CK_ULONG_PTR pusSignatureLen)
1364 {
1365 SFTK_FIPSCHECK();
1366 CHECK_FORK();
1367
1368 return NSC_SignFinal(hSession, pSignature, pusSignatureLen);
1369 }
1370
1371 /*
1372 ************** Crypto Functions: Sign Recover ************************
1373 */
1374 /* FC_SignRecoverInit initializes a signature operation,
1375 * where the (digest) data can be recovered from the signature.
1376 * E.g. encryption with the user's private key */
1377 CK_RV
FC_SignRecoverInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1378 FC_SignRecoverInit(CK_SESSION_HANDLE hSession,
1379 CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1380 {
1381 SFTK_FIPSCHECK();
1382 CHECK_FORK();
1383
1384 rv = NSC_SignRecoverInit(hSession, pMechanism, hKey);
1385 if (sftk_audit_enabled) {
1386 sftk_AuditCryptInit("SignRecover", hSession, pMechanism, hKey, rv);
1387 }
1388 return rv;
1389 }
1390
1391 /* FC_SignRecover signs data in a single operation
1392 * where the (digest) data can be recovered from the signature.
1393 * E.g. encryption with the user's private key */
1394 CK_RV
FC_SignRecover(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG usDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pusSignatureLen)1395 FC_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
1396 CK_ULONG usDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pusSignatureLen)
1397 {
1398 SFTK_FIPSCHECK();
1399 CHECK_FORK();
1400
1401 return NSC_SignRecover(hSession, pData, usDataLen, pSignature, pusSignatureLen);
1402 }
1403
1404 /*
1405 ************** Crypto Functions: verify ************************
1406 */
1407
1408 /* FC_VerifyInit initializes a verification operation,
1409 * where the signature is an appendix to the data,
1410 * and plaintext cannot be recovered from the signature (e.g. DSA) */
1411 CK_RV
FC_VerifyInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1412 FC_VerifyInit(CK_SESSION_HANDLE hSession,
1413 CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1414 {
1415 SFTK_FIPSCHECK();
1416 CHECK_FORK();
1417
1418 rv = NSC_VerifyInit(hSession, pMechanism, hKey);
1419 if (sftk_audit_enabled) {
1420 sftk_AuditCryptInit("Verify", hSession, pMechanism, hKey, rv);
1421 }
1422 return rv;
1423 }
1424
1425 /* FC_Verify verifies a signature in a single-part operation,
1426 * where the signature is an appendix to the data,
1427 * and plaintext cannot be recovered from the signature */
1428 CK_RV
FC_Verify(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG usDataLen,CK_BYTE_PTR pSignature,CK_ULONG usSignatureLen)1429 FC_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
1430 CK_ULONG usDataLen, CK_BYTE_PTR pSignature, CK_ULONG usSignatureLen)
1431 {
1432 /* make sure we're legal */
1433 SFTK_FIPSCHECK();
1434 CHECK_FORK();
1435
1436 return NSC_Verify(hSession, pData, usDataLen, pSignature, usSignatureLen);
1437 }
1438
1439 /* FC_VerifyUpdate continues a multiple-part verification operation,
1440 * where the signature is an appendix to the data,
1441 * and plaintext cannot be recovered from the signature */
1442 CK_RV
FC_VerifyUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG usPartLen)1443 FC_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
1444 CK_ULONG usPartLen)
1445 {
1446 SFTK_FIPSCHECK();
1447 CHECK_FORK();
1448
1449 return NSC_VerifyUpdate(hSession, pPart, usPartLen);
1450 }
1451
1452 /* FC_VerifyFinal finishes a multiple-part verification operation,
1453 * checking the signature. */
1454 CK_RV
FC_VerifyFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG usSignatureLen)1455 FC_VerifyFinal(CK_SESSION_HANDLE hSession,
1456 CK_BYTE_PTR pSignature, CK_ULONG usSignatureLen)
1457 {
1458 SFTK_FIPSCHECK();
1459 CHECK_FORK();
1460
1461 return NSC_VerifyFinal(hSession, pSignature, usSignatureLen);
1462 }
1463
1464 /*
1465 ************** Crypto Functions: Verify Recover ************************
1466 */
1467
1468 /* FC_VerifyRecoverInit initializes a signature verification operation,
1469 * where the data is recovered from the signature.
1470 * E.g. Decryption with the user's public key */
1471 CK_RV
FC_VerifyRecoverInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1472 FC_VerifyRecoverInit(CK_SESSION_HANDLE hSession,
1473 CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1474 {
1475 SFTK_FIPSCHECK();
1476 CHECK_FORK();
1477
1478 rv = NSC_VerifyRecoverInit(hSession, pMechanism, hKey);
1479 if (sftk_audit_enabled) {
1480 sftk_AuditCryptInit("VerifyRecover", hSession, pMechanism, hKey, rv);
1481 }
1482 return rv;
1483 }
1484
1485 /* FC_VerifyRecover verifies a signature in a single-part operation,
1486 * where the data is recovered from the signature.
1487 * E.g. Decryption with the user's public key */
1488 CK_RV
FC_VerifyRecover(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG usSignatureLen,CK_BYTE_PTR pData,CK_ULONG_PTR pusDataLen)1489 FC_VerifyRecover(CK_SESSION_HANDLE hSession,
1490 CK_BYTE_PTR pSignature, CK_ULONG usSignatureLen,
1491 CK_BYTE_PTR pData, CK_ULONG_PTR pusDataLen)
1492 {
1493 SFTK_FIPSCHECK();
1494 CHECK_FORK();
1495
1496 return NSC_VerifyRecover(hSession, pSignature, usSignatureLen, pData,
1497 pusDataLen);
1498 }
1499
1500 /*
1501 **************************** Key Functions: ************************
1502 */
1503
1504 /* FC_GenerateKey generates a secret key, creating a new key object. */
1505 CK_RV
FC_GenerateKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phKey)1506 FC_GenerateKey(CK_SESSION_HANDLE hSession,
1507 CK_MECHANISM_PTR pMechanism, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
1508 CK_OBJECT_HANDLE_PTR phKey)
1509 {
1510 CK_BBOOL *boolptr;
1511
1512 SFTK_FIPSCHECK();
1513 CHECK_FORK();
1514
1515 /* all secret keys must be sensitive, if the upper level code tries to say
1516 * otherwise, reject it. */
1517 boolptr = (CK_BBOOL *)fc_getAttribute(pTemplate, ulCount, CKA_SENSITIVE);
1518 if (boolptr != NULL) {
1519 if (!(*boolptr)) {
1520 return CKR_ATTRIBUTE_VALUE_INVALID;
1521 }
1522 }
1523
1524 rv = NSC_GenerateKey(hSession, pMechanism, pTemplate, ulCount, phKey);
1525 if (sftk_audit_enabled) {
1526 sftk_AuditGenerateKey(hSession, pMechanism, pTemplate, ulCount, phKey, rv);
1527 }
1528 return rv;
1529 }
1530
1531 /* FC_GenerateKeyPair generates a public-key/private-key pair,
1532 * creating new key objects. */
1533 CK_RV
FC_GenerateKeyPair(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_ATTRIBUTE_PTR pPublicKeyTemplate,CK_ULONG usPublicKeyAttributeCount,CK_ATTRIBUTE_PTR pPrivateKeyTemplate,CK_ULONG usPrivateKeyAttributeCount,CK_OBJECT_HANDLE_PTR phPublicKey,CK_OBJECT_HANDLE_PTR phPrivateKey)1534 FC_GenerateKeyPair(CK_SESSION_HANDLE hSession,
1535 CK_MECHANISM_PTR pMechanism, CK_ATTRIBUTE_PTR pPublicKeyTemplate,
1536 CK_ULONG usPublicKeyAttributeCount, CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
1537 CK_ULONG usPrivateKeyAttributeCount, CK_OBJECT_HANDLE_PTR phPublicKey,
1538 CK_OBJECT_HANDLE_PTR phPrivateKey)
1539 {
1540 CK_BBOOL *boolptr;
1541 CK_RV crv;
1542
1543 SFTK_FIPSCHECK();
1544 CHECK_FORK();
1545
1546 /* all private keys must be sensitive, if the upper level code tries to say
1547 * otherwise, reject it. */
1548 boolptr = (CK_BBOOL *)fc_getAttribute(pPrivateKeyTemplate,
1549 usPrivateKeyAttributeCount, CKA_SENSITIVE);
1550 if (boolptr != NULL) {
1551 if (!(*boolptr)) {
1552 return CKR_ATTRIBUTE_VALUE_INVALID;
1553 }
1554 }
1555 crv = NSC_GenerateKeyPair(hSession, pMechanism, pPublicKeyTemplate,
1556 usPublicKeyAttributeCount, pPrivateKeyTemplate,
1557 usPrivateKeyAttributeCount, phPublicKey, phPrivateKey);
1558 if (crv == CKR_GENERAL_ERROR) {
1559 /* pairwise consistency check failed. */
1560 sftk_fatalError = PR_TRUE;
1561 }
1562 if (sftk_audit_enabled) {
1563 sftk_AuditGenerateKeyPair(hSession, pMechanism, pPublicKeyTemplate,
1564 usPublicKeyAttributeCount, pPrivateKeyTemplate,
1565 usPrivateKeyAttributeCount, phPublicKey, phPrivateKey, crv);
1566 }
1567 return crv;
1568 }
1569
1570 /* FC_WrapKey wraps (i.e., encrypts) a key. */
1571 CK_RV
FC_WrapKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hWrappingKey,CK_OBJECT_HANDLE hKey,CK_BYTE_PTR pWrappedKey,CK_ULONG_PTR pulWrappedKeyLen)1572 FC_WrapKey(CK_SESSION_HANDLE hSession,
1573 CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hWrappingKey,
1574 CK_OBJECT_HANDLE hKey, CK_BYTE_PTR pWrappedKey,
1575 CK_ULONG_PTR pulWrappedKeyLen)
1576 {
1577 SFTK_FIPSCHECK();
1578 CHECK_FORK();
1579
1580 rv = NSC_WrapKey(hSession, pMechanism, hWrappingKey, hKey, pWrappedKey,
1581 pulWrappedKeyLen);
1582 if (sftk_audit_enabled) {
1583 sftk_AuditWrapKey(hSession, pMechanism, hWrappingKey, hKey, pWrappedKey,
1584 pulWrappedKeyLen, rv);
1585 }
1586 return rv;
1587 }
1588
1589 /* FC_UnwrapKey unwraps (decrypts) a wrapped key, creating a new key object. */
1590 CK_RV
FC_UnwrapKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hUnwrappingKey,CK_BYTE_PTR pWrappedKey,CK_ULONG ulWrappedKeyLen,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulAttributeCount,CK_OBJECT_HANDLE_PTR phKey)1591 FC_UnwrapKey(CK_SESSION_HANDLE hSession,
1592 CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hUnwrappingKey,
1593 CK_BYTE_PTR pWrappedKey, CK_ULONG ulWrappedKeyLen,
1594 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulAttributeCount,
1595 CK_OBJECT_HANDLE_PTR phKey)
1596 {
1597 CK_BBOOL *boolptr;
1598
1599 SFTK_FIPSCHECK();
1600 CHECK_FORK();
1601
1602 /* all secret keys must be sensitive, if the upper level code tries to say
1603 * otherwise, reject it. */
1604 boolptr = (CK_BBOOL *)fc_getAttribute(pTemplate,
1605 ulAttributeCount, CKA_SENSITIVE);
1606 if (boolptr != NULL) {
1607 if (!(*boolptr)) {
1608 return CKR_ATTRIBUTE_VALUE_INVALID;
1609 }
1610 }
1611 rv = NSC_UnwrapKey(hSession, pMechanism, hUnwrappingKey, pWrappedKey,
1612 ulWrappedKeyLen, pTemplate, ulAttributeCount, phKey);
1613 if (sftk_audit_enabled) {
1614 sftk_AuditUnwrapKey(hSession, pMechanism, hUnwrappingKey, pWrappedKey,
1615 ulWrappedKeyLen, pTemplate, ulAttributeCount, phKey, rv);
1616 }
1617 return rv;
1618 }
1619
1620 /* FC_DeriveKey derives a key from a base key, creating a new key object. */
1621 CK_RV
FC_DeriveKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hBaseKey,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulAttributeCount,CK_OBJECT_HANDLE_PTR phKey)1622 FC_DeriveKey(CK_SESSION_HANDLE hSession,
1623 CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hBaseKey,
1624 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulAttributeCount,
1625 CK_OBJECT_HANDLE_PTR phKey)
1626 {
1627 CK_BBOOL *boolptr;
1628
1629 SFTK_FIPSCHECK();
1630 CHECK_FORK();
1631
1632 /* all secret keys must be sensitive, if the upper level code tries to say
1633 * otherwise, reject it. */
1634 boolptr = (CK_BBOOL *)fc_getAttribute(pTemplate,
1635 ulAttributeCount, CKA_SENSITIVE);
1636 if (boolptr != NULL) {
1637 if (!(*boolptr)) {
1638 return CKR_ATTRIBUTE_VALUE_INVALID;
1639 }
1640 }
1641 rv = NSC_DeriveKey(hSession, pMechanism, hBaseKey, pTemplate,
1642 ulAttributeCount, phKey);
1643 if (sftk_audit_enabled) {
1644 sftk_AuditDeriveKey(hSession, pMechanism, hBaseKey, pTemplate,
1645 ulAttributeCount, phKey, rv);
1646 }
1647 return rv;
1648 }
1649
1650 /*
1651 **************************** Radom Functions: ************************
1652 */
1653
1654 /* FC_SeedRandom mixes additional seed material into the token's random number
1655 * generator. */
1656 CK_RV
FC_SeedRandom(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSeed,CK_ULONG usSeedLen)1657 FC_SeedRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed,
1658 CK_ULONG usSeedLen)
1659 {
1660 CK_RV crv;
1661
1662 SFTK_FIPSFATALCHECK();
1663 CHECK_FORK();
1664
1665 crv = NSC_SeedRandom(hSession, pSeed, usSeedLen);
1666 if (crv != CKR_OK) {
1667 sftk_fatalError = PR_TRUE;
1668 }
1669 return crv;
1670 }
1671
1672 /* FC_GenerateRandom generates random data. */
1673 CK_RV
FC_GenerateRandom(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pRandomData,CK_ULONG ulRandomLen)1674 FC_GenerateRandom(CK_SESSION_HANDLE hSession,
1675 CK_BYTE_PTR pRandomData, CK_ULONG ulRandomLen)
1676 {
1677 CK_RV crv;
1678
1679 CHECK_FORK();
1680
1681 SFTK_FIPSFATALCHECK();
1682 crv = NSC_GenerateRandom(hSession, pRandomData, ulRandomLen);
1683 if (crv != CKR_OK) {
1684 sftk_fatalError = PR_TRUE;
1685 if (sftk_audit_enabled) {
1686 char msg[128];
1687 PR_snprintf(msg, sizeof msg,
1688 "C_GenerateRandom(hSession=0x%08lX, pRandomData=%p, "
1689 "ulRandomLen=%lu)=0x%08lX "
1690 "self-test: continuous RNG test failed",
1691 (PRUint32)hSession, pRandomData,
1692 (PRUint32)ulRandomLen, (PRUint32)crv);
1693 sftk_LogAuditMessage(NSS_AUDIT_ERROR, NSS_AUDIT_SELF_TEST, msg);
1694 }
1695 }
1696 return crv;
1697 }
1698
1699 /* FC_GetFunctionStatus obtains an updated status of a function running
1700 * in parallel with an application. */
1701 CK_RV
FC_GetFunctionStatus(CK_SESSION_HANDLE hSession)1702 FC_GetFunctionStatus(CK_SESSION_HANDLE hSession)
1703 {
1704 SFTK_FIPSCHECK();
1705 CHECK_FORK();
1706
1707 return NSC_GetFunctionStatus(hSession);
1708 }
1709
1710 /* FC_CancelFunction cancels a function running in parallel */
1711 CK_RV
FC_CancelFunction(CK_SESSION_HANDLE hSession)1712 FC_CancelFunction(CK_SESSION_HANDLE hSession)
1713 {
1714 SFTK_FIPSCHECK();
1715 CHECK_FORK();
1716
1717 return NSC_CancelFunction(hSession);
1718 }
1719
1720 /*
1721 **************************** Version 1.1 Functions: ************************
1722 */
1723
1724 /* FC_GetOperationState saves the state of the cryptographic
1725 *operation in a session. */
1726 CK_RV
FC_GetOperationState(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pOperationState,CK_ULONG_PTR pulOperationStateLen)1727 FC_GetOperationState(CK_SESSION_HANDLE hSession,
1728 CK_BYTE_PTR pOperationState, CK_ULONG_PTR pulOperationStateLen)
1729 {
1730 SFTK_FIPSFATALCHECK();
1731 CHECK_FORK();
1732
1733 return NSC_GetOperationState(hSession, pOperationState, pulOperationStateLen);
1734 }
1735
1736 /* FC_SetOperationState restores the state of the cryptographic operation
1737 * in a session. */
1738 CK_RV
FC_SetOperationState(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pOperationState,CK_ULONG ulOperationStateLen,CK_OBJECT_HANDLE hEncryptionKey,CK_OBJECT_HANDLE hAuthenticationKey)1739 FC_SetOperationState(CK_SESSION_HANDLE hSession,
1740 CK_BYTE_PTR pOperationState, CK_ULONG ulOperationStateLen,
1741 CK_OBJECT_HANDLE hEncryptionKey, CK_OBJECT_HANDLE hAuthenticationKey)
1742 {
1743 SFTK_FIPSFATALCHECK();
1744 CHECK_FORK();
1745
1746 return NSC_SetOperationState(hSession, pOperationState, ulOperationStateLen,
1747 hEncryptionKey, hAuthenticationKey);
1748 }
1749
1750 /* FC_FindObjectsFinal finishes a search for token and session objects. */
1751 CK_RV
FC_FindObjectsFinal(CK_SESSION_HANDLE hSession)1752 FC_FindObjectsFinal(CK_SESSION_HANDLE hSession)
1753 {
1754 /* let publically readable object be found */
1755 SFTK_FIPSFATALCHECK();
1756 CHECK_FORK();
1757
1758 return NSC_FindObjectsFinal(hSession);
1759 }
1760
1761 /* Dual-function cryptographic operations */
1762
1763 /* FC_DigestEncryptUpdate continues a multiple-part digesting and encryption
1764 * operation. */
1765 CK_RV
FC_DigestEncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)1766 FC_DigestEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
1767 CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart,
1768 CK_ULONG_PTR pulEncryptedPartLen)
1769 {
1770 SFTK_FIPSCHECK();
1771 CHECK_FORK();
1772
1773 return NSC_DigestEncryptUpdate(hSession, pPart, ulPartLen, pEncryptedPart,
1774 pulEncryptedPartLen);
1775 }
1776
1777 /* FC_DecryptDigestUpdate continues a multiple-part decryption and digesting
1778 * operation. */
1779 CK_RV
FC_DecryptDigestUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)1780 FC_DecryptDigestUpdate(CK_SESSION_HANDLE hSession,
1781 CK_BYTE_PTR pEncryptedPart, CK_ULONG ulEncryptedPartLen,
1782 CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen)
1783 {
1784 SFTK_FIPSCHECK();
1785 CHECK_FORK();
1786
1787 return NSC_DecryptDigestUpdate(hSession, pEncryptedPart, ulEncryptedPartLen,
1788 pPart, pulPartLen);
1789 }
1790
1791 /* FC_SignEncryptUpdate continues a multiple-part signing and encryption
1792 * operation. */
1793 CK_RV
FC_SignEncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)1794 FC_SignEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
1795 CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart,
1796 CK_ULONG_PTR pulEncryptedPartLen)
1797 {
1798 SFTK_FIPSCHECK();
1799 CHECK_FORK();
1800
1801 return NSC_SignEncryptUpdate(hSession, pPart, ulPartLen, pEncryptedPart,
1802 pulEncryptedPartLen);
1803 }
1804
1805 /* FC_DecryptVerifyUpdate continues a multiple-part decryption and verify
1806 * operation. */
1807 CK_RV
FC_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedData,CK_ULONG ulEncryptedDataLen,CK_BYTE_PTR pData,CK_ULONG_PTR pulDataLen)1808 FC_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession,
1809 CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen,
1810 CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen)
1811 {
1812 SFTK_FIPSCHECK();
1813 CHECK_FORK();
1814
1815 return NSC_DecryptVerifyUpdate(hSession, pEncryptedData, ulEncryptedDataLen,
1816 pData, pulDataLen);
1817 }
1818
1819 /* FC_DigestKey continues a multi-part message-digesting operation,
1820 * by digesting the value of a secret key as part of the data already digested.
1821 */
1822 CK_RV
FC_DigestKey(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hKey)1823 FC_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey)
1824 {
1825 SFTK_FIPSCHECK();
1826 CHECK_FORK();
1827
1828 rv = NSC_DigestKey(hSession, hKey);
1829 if (sftk_audit_enabled) {
1830 sftk_AuditDigestKey(hSession, hKey, rv);
1831 }
1832 return rv;
1833 }
1834
1835 CK_RV
FC_WaitForSlotEvent(CK_FLAGS flags,CK_SLOT_ID_PTR pSlot,CK_VOID_PTR pReserved)1836 FC_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR pSlot,
1837 CK_VOID_PTR pReserved)
1838 {
1839 CHECK_FORK();
1840
1841 return NSC_WaitForSlotEvent(flags, pSlot, pReserved);
1842 }
1843
1844 CK_RV
FC_MessageEncryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1845 FC_MessageEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
1846 CK_OBJECT_HANDLE hKey)
1847 {
1848 SFTK_FIPSCHECK();
1849 CHECK_FORK();
1850
1851 rv = NSC_MessageEncryptInit(hSession, pMechanism, hKey);
1852 if (sftk_audit_enabled) {
1853 sftk_AuditCryptInit("MessageEncrypt", hSession, pMechanism, hKey, rv);
1854 }
1855 return rv;
1856 }
1857
1858 CK_RV
FC_EncryptMessage(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pAssociatedData,CK_ULONG ulAssociatedDataLen,CK_BYTE_PTR pPlaintext,CK_ULONG ulPlaintextLen,CK_BYTE_PTR pCiphertext,CK_ULONG_PTR pulCiphertextLen)1859 FC_EncryptMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
1860 CK_ULONG ulParameterLen, CK_BYTE_PTR pAssociatedData,
1861 CK_ULONG ulAssociatedDataLen, CK_BYTE_PTR pPlaintext,
1862 CK_ULONG ulPlaintextLen, CK_BYTE_PTR pCiphertext,
1863 CK_ULONG_PTR pulCiphertextLen)
1864 {
1865 SFTK_FIPSCHECK();
1866 CHECK_FORK();
1867 return NSC_EncryptMessage(hSession, pParameter, ulParameterLen,
1868 pAssociatedData, ulAssociatedDataLen,
1869 pPlaintext, ulPlaintextLen, pCiphertext,
1870 pulCiphertextLen);
1871 }
1872
1873 CK_RV
FC_EncryptMessageBegin(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pAssociatedData,CK_ULONG ulAssociatedDataLen)1874 FC_EncryptMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
1875 CK_ULONG ulParameterLen, CK_BYTE_PTR pAssociatedData,
1876 CK_ULONG ulAssociatedDataLen)
1877 {
1878 SFTK_FIPSCHECK();
1879 CHECK_FORK();
1880 return NSC_EncryptMessageBegin(hSession, pParameter, ulParameterLen,
1881 pAssociatedData, ulAssociatedDataLen);
1882 }
1883
1884 CK_RV
FC_EncryptMessageNext(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pPlaintextPart,CK_ULONG ulPlaintextPartLen,CK_BYTE_PTR pCiphertextPart,CK_ULONG_PTR pulCiphertextPartLen,CK_FLAGS flags)1885 FC_EncryptMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
1886 CK_ULONG ulParameterLen, CK_BYTE_PTR pPlaintextPart,
1887 CK_ULONG ulPlaintextPartLen, CK_BYTE_PTR pCiphertextPart,
1888 CK_ULONG_PTR pulCiphertextPartLen, CK_FLAGS flags)
1889 {
1890 SFTK_FIPSCHECK();
1891 CHECK_FORK();
1892 return NSC_EncryptMessageNext(hSession, pParameter, ulParameterLen,
1893 pPlaintextPart, ulPlaintextPartLen,
1894 pCiphertextPart, pulCiphertextPartLen, flags);
1895 }
1896
1897 CK_RV
FC_MessageEncryptFinal(CK_SESSION_HANDLE hSession)1898 FC_MessageEncryptFinal(CK_SESSION_HANDLE hSession)
1899 {
1900 SFTK_FIPSCHECK();
1901 CHECK_FORK();
1902 return NSC_MessageEncryptFinal(hSession);
1903 }
1904
1905 CK_RV
FC_MessageDecryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1906 FC_MessageDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
1907 CK_OBJECT_HANDLE hKey)
1908 {
1909 SFTK_FIPSCHECK();
1910 CHECK_FORK();
1911
1912 rv = NSC_MessageDecryptInit(hSession, pMechanism, hKey);
1913 if (sftk_audit_enabled) {
1914 sftk_AuditCryptInit("MessageDecrypt", hSession, pMechanism, hKey, rv);
1915 }
1916 return rv;
1917 }
1918
1919 CK_RV
FC_DecryptMessage(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pAssociatedData,CK_ULONG ulAssociatedDataLen,CK_BYTE_PTR pCiphertext,CK_ULONG ulCiphertextLen,CK_BYTE_PTR pPlaintext,CK_ULONG_PTR pulPlaintextLen)1920 FC_DecryptMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
1921 CK_ULONG ulParameterLen, CK_BYTE_PTR pAssociatedData,
1922 CK_ULONG ulAssociatedDataLen, CK_BYTE_PTR pCiphertext,
1923 CK_ULONG ulCiphertextLen, CK_BYTE_PTR pPlaintext,
1924 CK_ULONG_PTR pulPlaintextLen)
1925 {
1926 SFTK_FIPSCHECK();
1927 CHECK_FORK();
1928 return NSC_DecryptMessage(hSession, pParameter, ulParameterLen,
1929 pAssociatedData, ulAssociatedDataLen,
1930 pCiphertext, ulCiphertextLen, pPlaintext,
1931 pulPlaintextLen);
1932 }
1933
1934 CK_RV
FC_DecryptMessageBegin(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pAssociatedData,CK_ULONG ulAssociatedDataLen)1935 FC_DecryptMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
1936 CK_ULONG ulParameterLen, CK_BYTE_PTR pAssociatedData,
1937 CK_ULONG ulAssociatedDataLen)
1938 {
1939 SFTK_FIPSCHECK();
1940 CHECK_FORK();
1941 return NSC_DecryptMessageBegin(hSession, pParameter, ulParameterLen,
1942 pAssociatedData, ulAssociatedDataLen);
1943 }
1944
1945 CK_RV
FC_DecryptMessageNext(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pCiphertextPart,CK_ULONG ulCiphertextPartLen,CK_BYTE_PTR pPlaintextPart,CK_ULONG_PTR pulPlaintextPartLen,CK_FLAGS flags)1946 FC_DecryptMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
1947 CK_ULONG ulParameterLen, CK_BYTE_PTR pCiphertextPart,
1948 CK_ULONG ulCiphertextPartLen, CK_BYTE_PTR pPlaintextPart,
1949 CK_ULONG_PTR pulPlaintextPartLen, CK_FLAGS flags)
1950 {
1951 SFTK_FIPSCHECK();
1952 CHECK_FORK();
1953 return NSC_DecryptMessageNext(hSession, pParameter, ulParameterLen,
1954 pCiphertextPart, ulCiphertextPartLen,
1955 pPlaintextPart, pulPlaintextPartLen, flags);
1956 }
1957
1958 CK_RV
FC_MessageDecryptFinal(CK_SESSION_HANDLE hSession)1959 FC_MessageDecryptFinal(CK_SESSION_HANDLE hSession)
1960 {
1961 SFTK_FIPSCHECK();
1962 CHECK_FORK();
1963 return NSC_MessageDecryptFinal(hSession);
1964 }
1965
1966 CK_RV
FC_MessageSignInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1967 FC_MessageSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
1968 CK_OBJECT_HANDLE hKey)
1969 {
1970 SFTK_FIPSCHECK();
1971 CHECK_FORK();
1972
1973 rv = NSC_MessageSignInit(hSession, pMechanism, hKey);
1974 if (sftk_audit_enabled) {
1975 sftk_AuditCryptInit("MessageSign", hSession, pMechanism, hKey, rv);
1976 }
1977 return rv;
1978 }
1979
1980 CK_RV
FC_SignMessage(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1981 FC_SignMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
1982 CK_ULONG ulParameterLen, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
1983 CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
1984 {
1985 SFTK_FIPSCHECK();
1986 CHECK_FORK();
1987 return NSC_SignMessage(hSession, pParameter, ulParameterLen, pData,
1988 ulDataLen, pSignature, pulSignatureLen);
1989 }
1990
1991 CK_RV
FC_SignMessageBegin(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen)1992 FC_SignMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
1993 CK_ULONG ulParameterLen)
1994 {
1995 SFTK_FIPSCHECK();
1996 CHECK_FORK();
1997 return NSC_SignMessageBegin(hSession, pParameter, ulParameterLen);
1998 }
1999
2000 CK_RV
FC_SignMessageNext(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)2001 FC_SignMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
2002 CK_ULONG ulParameterLen, CK_BYTE_PTR pData,
2003 CK_ULONG ulDataLen, CK_BYTE_PTR pSignature,
2004 CK_ULONG_PTR pulSignatureLen)
2005 {
2006 SFTK_FIPSCHECK();
2007 CHECK_FORK();
2008 return NSC_SignMessageNext(hSession, pParameter, ulParameterLen, pData,
2009 ulDataLen, pSignature, pulSignatureLen);
2010 }
2011
2012 CK_RV
FC_MessageSignFinal(CK_SESSION_HANDLE hSession)2013 FC_MessageSignFinal(CK_SESSION_HANDLE hSession)
2014 {
2015 SFTK_FIPSCHECK();
2016 CHECK_FORK();
2017 return NSC_MessageSignFinal(hSession);
2018 }
2019
2020 CK_RV
FC_MessageVerifyInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)2021 FC_MessageVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
2022 CK_OBJECT_HANDLE hKey)
2023 {
2024 SFTK_FIPSCHECK();
2025 CHECK_FORK();
2026
2027 rv = NSC_MessageVerifyInit(hSession, pMechanism, hKey);
2028 if (sftk_audit_enabled) {
2029 sftk_AuditCryptInit("MessageVerify", hSession, pMechanism, hKey, rv);
2030 }
2031 return rv;
2032 }
2033
2034 CK_RV
FC_VerifyMessage(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)2035 FC_VerifyMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
2036 CK_ULONG ulParameterLen, CK_BYTE_PTR pData,
2037 CK_ULONG ulDataLen, CK_BYTE_PTR pSignature,
2038 CK_ULONG ulSignatureLen)
2039 {
2040 SFTK_FIPSCHECK();
2041 CHECK_FORK();
2042 return NSC_VerifyMessage(hSession, pParameter, ulParameterLen, pData,
2043 ulDataLen, pSignature, ulSignatureLen);
2044 }
2045
2046 CK_RV
FC_VerifyMessageBegin(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen)2047 FC_VerifyMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
2048 CK_ULONG ulParameterLen)
2049 {
2050 SFTK_FIPSCHECK();
2051 CHECK_FORK();
2052 return NSC_VerifyMessageBegin(hSession, pParameter, ulParameterLen);
2053 }
2054
2055 CK_RV
FC_VerifyMessageNext(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)2056 FC_VerifyMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter,
2057 CK_ULONG ulParameterLen, CK_BYTE_PTR pData,
2058 CK_ULONG ulDataLen, CK_BYTE_PTR pSignature,
2059 CK_ULONG ulSignatureLen)
2060 {
2061 SFTK_FIPSCHECK();
2062 CHECK_FORK();
2063 return NSC_VerifyMessageNext(hSession, pParameter, ulParameterLen,
2064 pData, ulDataLen, pSignature, ulSignatureLen);
2065 }
2066
2067 CK_RV
FC_MessageVerifyFinal(CK_SESSION_HANDLE hSession)2068 FC_MessageVerifyFinal(CK_SESSION_HANDLE hSession)
2069 {
2070 SFTK_FIPSCHECK();
2071 CHECK_FORK();
2072 return NSC_MessageVerifyFinal(hSession);
2073 }
2074