/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c

Bug Summary

File:	root/firefox-clang/security/nss/lib/softoken/pkcs11u.c
Warning:	line 2104, column 17 Null pointer passed to 1st parameter expecting 'nonnull'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pkcs11u.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/security/nss/lib/softoken/softoken_softokn -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/security/nss/lib/softoken/softoken_softokn -resource-dir /usr/lib/llvm-23/lib/clang/23 -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG -D SHLIB_SUFFIX="so" -D SHLIB_PREFIX="lib" -D SOFTOKEN_LIB_NAME="libsoftokn3.so" -D SHLIB_VERSION="3" -D NSS_FIPS_DISABLED -D NSS_NO_INIT_SUPPORT -D NSS_X86_OR_X64 -D NSS_X64 -D NSS_USE_64 -D USE_UTIL_DIRECTLY -D NO_NSPR_10_SUPPORT -D SSL_DISABLE_DEPRECATED_CIPHER_SUITE_NAMES -D LINUX2_1 -D LINUX -D linux -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D HAVE_STRERROR -D XP_UNIX -D _REENTRANT -D NSS_DISABLE_DBM -D NSS_DISABLE_LIBPKIX -D NSS_USE_PKCS5_PBKD2_PARAMS2_ONLY -D SOFTOKEN_USE_PKCS5_PBKD2_PARAMS2_ONLY -I /root/firefox-clang/security/nss/lib/softoken -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/security/nss/lib/softoken/softoken_softokn -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/private/nss -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -D MOZILLA_CLIENT -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-error=tautological-type-limit-compare -Wno-range-loop-analysis -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-unknown-warning-option -Wno-character-conversion -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fdiagnostics-absolute-paths -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -mllvm -dwarf-linkage-names=Abstract -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-10-17-231001-351276-1 -x c /root/firefox-clang/security/nss/lib/softoken/pkcs11u.c
1/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4/*
* Internal PKCS #11 functions. Should only be called by pkcs11.c
*/
7#include "pkcs11.h"
8#include "pkcs11i.h"
9#include "lowkeyi.h"
10#include "secasn1.h"
11#include "blapi.h"
12#include "secerr.h"
13#include "prnetdb.h" /* for PR_ntohl */
14#include "sftkdb.h"
15#include "softoken.h"
16#include "secoid.h"
17#include "softkver.h"

19#if !defined(NSS_FIPS_DISABLED1) && defined(NSS_ENABLE_FIPS_INDICATORS)
20/* handle special cases. Classes require existing code to already be
* in place for that class */
22typedef enum {
  SFTKFIPSNone = 0,
  SFTKFIPSDH,           /* allow only specific primes */
  SFTKFIPSECC,          /* not just keys but specific curves */
  SFTKFIPSAEAD,         /* single shot AEAD functions not allowed in FIPS mode */
  SFTKFIPSRSAPSS,       /* make sure salt isn't too big */
  SFTKFIPSPBKDF2,       /* handle pbkdf2 FIPS restrictions */
  SFTKFIPSTlsKeyCheck,  /* check the output of TLS prf functions */
  SFTKFIPSChkHash,      /* make sure the base hash of KDF functions is FIPS */
  SFTKFIPSChkHashTls,   /* make sure the base hash of TLS KDF functions is FIPS */
  SFTKFIPSChkHashSp800, /* make sure the base hash of SP-800-108 KDF functions is FIPS */
  SFTKFIPSRSAOAEP,      /* make sure that both hashes use the same FIPS compliant algorithm */
34} SFTKFIPSSpecialClass;

36typedef struct SFTKFIPSAlgorithmListStr SFTKFIPSAlgorithmList;
37struct SFTKFIPSAlgorithmListStr {
  CK_MECHANISM_TYPE type;
  CK_MECHANISM_INFO info;
  CK_ULONG step;
  SFTKFIPSSpecialClass special;
  size_t offset;
43};
44/* this file should be supplied by the vendor and include all the
* algorithms which have Algorithm certs and have been reviewed by
* the lab. A blank file is included for the base so that FIPS mode
* will still be compiled and run, but FIPS indicators will always
* return PR_FALSE
*/
50#include "fips_algorithms.h"

52#ifndef SFTKFIPS_PBKDF2_MIN_PW_LEN /* allow fips_algorithms.h to override */
53#define SFTKFIPS_PBKDF2_MIN_PW_LEN 8
54#endif
55#define NSS_HAS_FIPS_INDICATORS 1
56#endif

58/*
* ******************** Error mapping *******************************
*/
61/*
* map all the SEC_ERROR_xxx error codes that may be returned by freebl
* functions to CKR_xxx.  return CKR_DEVICE_ERROR by default for backward
* compatibility.
*/
66CK_RV
67sftk_MapCryptError(int error)
68{
  switch (error) {
      case SEC_ERROR_INVALID_ARGS:
      case SEC_ERROR_BAD_DATA: /* MP_RANGE gets mapped to this */
          return CKR_ARGUMENTS_BAD0x00000007UL;
      case SEC_ERROR_INPUT_LEN:
          return CKR_DATA_LEN_RANGE0x00000021UL;
      case SEC_ERROR_OUTPUT_LEN:
          return CKR_BUFFER_TOO_SMALL0x00000150UL;
      case SEC_ERROR_LIBRARY_FAILURE:
          return CKR_GENERAL_ERROR0x00000005UL;
      case SEC_ERROR_NO_MEMORY:
          return CKR_HOST_MEMORY0x00000002UL;
      case SEC_ERROR_BAD_SIGNATURE:
          return CKR_SIGNATURE_INVALID0x000000C0UL;
      case SEC_ERROR_INVALID_KEY:
          return CKR_KEY_SIZE_RANGE0x00000062UL;
      case SEC_ERROR_BAD_KEY:        /* an EC public key that fails validation */
          return CKR_KEY_SIZE_RANGE0x00000062UL; /* the closest error code */
      case SEC_ERROR_UNSUPPORTED_EC_POINT_FORM:
          return CKR_TEMPLATE_INCONSISTENT0x000000D1UL;
      case SEC_ERROR_UNSUPPORTED_KEYALG:
          return CKR_MECHANISM_INVALID0x00000070UL;
      case SEC_ERROR_UNSUPPORTED_ELLIPTIC_CURVE:
          return CKR_DOMAIN_PARAMS_INVALID0x00000130UL;
      /* key pair generation failed after max number of attempts */
      case SEC_ERROR_NEED_RANDOM:
          return CKR_FUNCTION_FAILED0x00000006UL;
  }
  return CKR_DEVICE_ERROR0x00000030UL;
98}

100/*
* functions which adjust the mapping based on different contexts
* (Decrypt or Verify).
*/

105/* used by Decrypt and UnwrapKey (indirectly) and Decrypt message */
106CK_RV
107sftk_MapDecryptError(int error)
108{
  switch (error) {
      /* usually a padding error, or aead tag mismatch */
      case SEC_ERROR_BAD_DATA:
          return CKR_ENCRYPTED_DATA_INVALID0x00000040UL;
      default:
          return sftk_MapCryptError(error);
  }
116}

118/*
* return CKR_SIGNATURE_INVALID instead of CKR_DEVICE_ERROR by default for
* backward compatibilty.
*/
122CK_RV
123sftk_MapVerifyError(int error)
124{
  CK_RV crv = sftk_MapCryptError(error);
  if (crv == CKR_DEVICE_ERROR0x00000030UL)
      crv = CKR_SIGNATURE_INVALID0x000000C0UL;
  return crv;
129}

131/*
* ******************** Attribute Utilities *******************************
*/

135/*
* create a new attribute with type, value, and length. Space is allocated
* to hold value.
*/
139static SFTKAttribute *
140sftk_InitAttribute(SFTKSessionObject *so, int index,
                 CK_ATTRIBUTE_TYPE type, const void *value, CK_ULONG len)
142{
  SFTKAttribute *attribute;

  PORT_Assert(index < MAX_OBJS_ATTRS)((index < 45) ? ((void)0) : PR_Assert("index < MAX_OBJS_ATTRS"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 145
));
  if (index >= MAX_OBJS_ATTRS45)
      return NULL((void*)0);

  attribute = &so->attrList[index];
  attribute->attrib.type = type;
  attribute->freeAttr = PR_FALSE0;
  attribute->freeData = PR_FALSE0;
  if (value) {
      if (len <= ATTR_SPACE50) {
          attribute->attrib.pValue = attribute->space;
      } else {
          attribute->attrib.pValue = PORT_AllocPORT_Alloc_Util(len);
          attribute->freeData = PR_TRUE1;
      }
      if (attribute->attrib.pValue == NULL((void*)0)) {
          return NULL((void*)0);
      }
      PORT_Memcpymemcpy(attribute->attrib.pValue, value, len);
      attribute->attrib.ulValueLen = len;
  } else {
      attribute->attrib.pValue = NULL((void*)0);
      attribute->attrib.ulValueLen = 0;
  }
  attribute->attrib.type = type;
  attribute->handle = type;
  attribute->next = attribute->prev = NULL((void*)0);
  return attribute;
173}

175static SFTKAttribute *
176sftk_NewAttribute(SFTKObject *object,
                CK_ATTRIBUTE_TYPE type, const void *value, CK_ULONG len)
178{
  SFTKSessionObject *so = sftk_narrowToSessionObject(object);
  int index;

  if (so == NULL((void*)0)) {
      /* allocate new attribute in a buffer */
      PORT_Assert(0)((0) ? ((void)0) : PR_Assert("0", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 184));
      return NULL((void*)0);
  }
  /*
   * We attempt to keep down contention on Malloc and Arena locks by
   * limiting the number of these calls on high traversed paths. This
   * is done for attributes by 'allocating' them from a pool already
   * allocated by the parent object.
   */
  PR_Lock(so->attributeLock);
  index = so->nextAttr++;
  PR_Unlock(so->attributeLock);
  return sftk_InitAttribute(so, index, type, value, len);
197}

199/*
* Free up all the memory associated with an attribute. Reference count
* must be zero to call this.
*/
203static void
204sftk_DestroyAttribute(SFTKAttribute *attribute)
205{
  if (attribute->attrib.pValue) {
      /* clear out the data in the attribute value... it may have been
       * sensitive data */
      PORT_Memsetmemset(attribute->attrib.pValue, 0, attribute->attrib.ulValueLen);
      if (attribute->freeData) {
          PORT_FreePORT_Free_Util(attribute->attrib.pValue);
          attribute->attrib.pValue = NULL((void*)0);
          attribute->freeData = PR_FALSE0;
      }
  }
  if (attribute->freeAttr) {
      PORT_FreePORT_Free_Util(attribute);
  }
219}

221/*
* release a reference to an attribute structure
*/
224void
225sftk_FreeAttribute(SFTKAttribute *attribute)
226{
  if (attribute && attribute->freeAttr) {
      sftk_DestroyAttribute(attribute);
      return;
  }
231}

233static SFTKAttribute *
234sftk_FindTokenAttribute(SFTKTokenObject *object, CK_ATTRIBUTE_TYPE type)
235{
  SFTKAttribute *myattribute = NULL((void*)0);
  SFTKDBHandle *dbHandle = NULL((void*)0);
  CK_RV crv = CKR_HOST_MEMORY0x00000002UL;

  if (object == NULL((void*)0)) {
      return NULL((void*)0);
  }
  myattribute = (SFTKAttribute *)PORT_AllocPORT_Alloc_Util(sizeof(SFTKAttribute));
  if (myattribute == NULL((void*)0)) {
      goto loser;
  }

  dbHandle = sftk_getDBForTokenObject(object->obj.slot, object->obj.handle);

  myattribute->handle = type;
  myattribute->attrib.type = type;
  myattribute->attrib.pValue = myattribute->space;
  myattribute->attrib.ulValueLen = ATTR_SPACE50;
  myattribute->next = myattribute->prev = NULL((void*)0);
  myattribute->freeAttr = PR_TRUE1;
  myattribute->freeData = PR_FALSE0;

  crv = sftkdb_GetAttributeValue(dbHandle, object->obj.handle,
                                 &myattribute->attrib, 1);

  /* attribute is bigger than our attribute space buffer, malloc it */
  if (crv == CKR_BUFFER_TOO_SMALL0x00000150UL) {
      myattribute->attrib.pValue = NULL((void*)0);
      crv = sftkdb_GetAttributeValue(dbHandle, object->obj.handle,
                                     &myattribute->attrib, 1);
      if (crv != CKR_OK0x00000000UL) {
          goto loser;
      }
      myattribute->attrib.pValue = PORT_AllocPORT_Alloc_Util(myattribute->attrib.ulValueLen);
      if (myattribute->attrib.pValue == NULL((void*)0)) {
          crv = CKR_HOST_MEMORY0x00000002UL;
          goto loser;
      }
      myattribute->freeData = PR_TRUE1;
      crv = sftkdb_GetAttributeValue(dbHandle, object->obj.handle,
                                     &myattribute->attrib, 1);
  }
278loser:
  if (dbHandle) {
      sftk_freeDB(dbHandle);
  }
  if (crv != CKR_OK0x00000000UL) {
      if (myattribute) {
          myattribute->attrib.ulValueLen = 0;
          sftk_FreeAttribute(myattribute);
          myattribute = NULL((void*)0);
      }
  }
  return myattribute;
290}

292/*
* Make a detached, owned copy of a session object's attribute. Must be
* called with sessObject->attributeLock held so the (pValue, ulValueLen)
* pair is captured atomically with respect to sftk_forceAttribute() and
* friends. The copy carries freeAttr = PR_TRUE, so sftk_FreeAttribute()
* releases it; callers may read it without holding any lock.
*/
299static SFTKAttribute *
300sftk_CopyAttribute(const SFTKAttribute *attribute)
301{
  SFTKAttribute *copy = (SFTKAttribute *)PORT_AllocPORT_Alloc_Util(sizeof(SFTKAttribute));
  if (copy == NULL((void*)0)) {
19
←
Assuming 'copy' is not equal to NULL→
20
←
Taking false branch→
      return NULL((void*)0);
  }
  copy->next = copy->prev = NULL((void*)0);
  copy->freeAttr = PR_TRUE1;
  copy->freeData = PR_FALSE0;
  copy->handle = attribute->handle;
  copy->attrib.type = attribute->attrib.type;
  if (attribute->attrib.pValue == NULL((void*)0)) {
21
←
Assuming field 'pValue' is equal to NULL→
22
←
Taking true branch→
      copy->attrib.pValue = NULL((void*)0);
23
←
Null pointer value stored to field 'pValue'→
      copy->attrib.ulValueLen = 0;
      return copy;
  }
  if (attribute->attrib.ulValueLen <= ATTR_SPACE50) {
      copy->attrib.pValue = copy->space;
  } else {
      copy->attrib.pValue = PORT_AllocPORT_Alloc_Util(attribute->attrib.ulValueLen);
      if (copy->attrib.pValue == NULL((void*)0)) {
          PORT_FreePORT_Free_Util(copy);
          return NULL((void*)0);
      }
      copy->freeData = PR_TRUE1;
  }
  PORT_Memcpymemcpy(copy->attrib.pValue, attribute->attrib.pValue,
              attribute->attrib.ulValueLen);
  copy->attrib.ulValueLen = attribute->attrib.ulValueLen;
  return copy;
330}

332/*
* look up and attribute structure from a type and Object structure.
* The returned attribute is referenced and needs to be freed when
* it is no longer needed.
*/
337SFTKAttribute *
338sftk_FindAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
339{
  SFTKAttribute *attribute;
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);

  /* validation flags are stored as FIPS indicators */
  if (type == CKA_OBJECT_VALIDATION_FLAGS0x0000061eUL) {
9
←
Assuming 'type' is not equal to CKA_OBJECT_VALIDATION_FLAGS→
10
←
Taking false branch→
      return &object->validation_attribute;
  }

  if (sessObject10.1
'sessObject' is not equal to NULL
 == NULL((void*)0)) {
11
←
Taking false branch→
      return sftk_FindTokenAttribute(sftk_narrowToTokenObject(object), type);
  }

  /* Return a detached copy rather than the live pool entry: callers
   * dereference attrib.pValue after the lock is dropped, while a
   * concurrent sftk_forceAttribute() may free and reassign it.
   * Snapshotting under the lock gives the caller a stable,
   * private value (this matches the token-object path above). */
  PR_Lock(sessObject->attributeLock);
  sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize)for ((attribute) = (sessObject->head)[((PRUint32)((type) *
 1791398085) & (sessObject->hashSize - 1))]; (attribute
) != ((void*)0); (attribute) = (attribute)->next) { if ((attribute
)->handle == (type)) { break; } };
12
←
Assuming 'attribute' is not equal to null→
13
←
Loop condition is true.  Entering loop body→
14
←
Assuming 'type' is equal to field 'handle'→
15
←
Taking true branch→
  if (attribute16.1
'attribute' is not equal to NULL
 != NULL((void*)0)) {
16
←
 Execution continues on line 359→
17
←
Taking true branch→
      attribute = sftk_CopyAttribute(attribute);
18
←
Calling 'sftk_CopyAttribute'→
24
←
Returning from 'sftk_CopyAttribute'→
  }
  PR_Unlock(sessObject->attributeLock);

  return (attribute);
365}

367/*
* Look up an attribute while the caller holds the object's attributeLock.
* Returns a BORROWED reference to the live node in sessObject->head[] (or
* the object's embedded validation attribute): valid only until the lock is
* released, and never to be passed to sftk_FreeAttribute().
*
* This is only valid for session objects (and CKA_OBJECT_VALIDATION_FLAGS).
* Token objects have no live node; callers that may see one must fall back
* to sftk_FindAttribute(). Returns NULL if the attribute is absent.
*
* The lock is NOT reentrant: while holding it, the caller must not call any
* attribute API that takes it itself (sftk_FindAttribute,
* sftk_AddAttributeType, sftk_forceAttribute, sftk_DeleteAttributeType).
*/
381static SFTKAttribute *
382sftk_FindAttributeLocked(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
383{
  SFTKSessionObject *sessObject;
  SFTKAttribute *attribute;

  /* validation flags are stored as FIPS indicators */
  if (type == CKA_OBJECT_VALIDATION_FLAGS0x0000061eUL) {
      return &object->validation_attribute;
  }

  sessObject = sftk_narrowToSessionObject(object);
  PORT_Assert(sessObject != NULL)((sessObject != ((void*)0)) ? ((void)0) : PR_Assert("sessObject != NULL"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 393
));
  if (sessObject == NULL((void*)0)) {
      return NULL((void*)0);
  }

  sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize)for ((attribute) = (sessObject->head)[((PRUint32)((type) *
 1791398085) & (sessObject->hashSize - 1))]; (attribute
) != ((void*)0); (attribute) = (attribute)->next) { if ((attribute
)->handle == (type)) { break; } };
  return attribute;
400}

402/*
* Take a buffer and it's length and return it's true size in bits;
*/
405unsigned int
406sftk_GetLengthInBits(unsigned char *buf, unsigned int bufLen)
407{
  unsigned int size = bufLen * 8;
  unsigned int i;

  /* Get the real length in bytes */
  for (i = 0; i < bufLen; i++) {
      unsigned char c = *buf++;
      if (c != 0) {
          unsigned char m;
          for (m = 0x80; m > 0; m = m >> 1) {
              if ((c & m) != 0) {
                  break;
              }
              size--;
          }
          break;
      }
      size -= 8;
  }
  return size;
427}

429/*
* Constrain a big num attribute. to size and padding
* minLength means length of the object must be greater than equal to minLength
* maxLength means length of the object must be less than equal to maxLength
* minMultiple means that object length mod minMultiple must equal 0.
* all input sizes are in bits.
* if any constraint is '0' that constraint is not checked.
*/
437CK_RV
438sftk_ConstrainAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
                      int minLength, int maxLength, int minMultiple)
440{
  SFTKAttribute *attribute;
  int size = 0;
  unsigned char *ptr;
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
  CK_RV crv = CKR_OK0x00000000UL;

  if (sessObject != NULL((void*)0)) {
      PR_Lock(sessObject->attributeLock);
      attribute = sftk_FindAttributeLocked(object, type);
  } else {
      attribute = sftk_FindAttribute(object, type);
  }

  if (!attribute) {
      crv = CKR_TEMPLATE_INCOMPLETE0x000000D0UL;
  } else {
      ptr = (unsigned char *)attribute->attrib.pValue;
      if (ptr == NULL((void*)0)) {
          crv = CKR_ATTRIBUTE_VALUE_INVALID0x00000013UL;
      } else {
          size = sftk_GetLengthInBits(ptr, attribute->attrib.ulValueLen);
      }
  }

  if (sessObject != NULL((void*)0)) {
      PR_Unlock(sessObject->attributeLock);
  } else {
      sftk_FreeAttribute(attribute);
  }
  if (crv != CKR_OK0x00000000UL) {
      return crv;
  }

  if ((minLength != 0) && (size < minLength)) {
      return CKR_ATTRIBUTE_VALUE_INVALID0x00000013UL;
  }
  if ((maxLength != 0) && (size > maxLength)) {
      return CKR_ATTRIBUTE_VALUE_INVALID0x00000013UL;
  }
  if ((minMultiple != 0) && ((size % minMultiple) != 0)) {
      return CKR_ATTRIBUTE_VALUE_INVALID0x00000013UL;
  }
  return CKR_OK0x00000000UL;
484}

486PRBool
487sftk_hasAttributeToken(SFTKTokenObject *object, CK_ATTRIBUTE_TYPE type)
488{
  CK_ATTRIBUTE template;
  CK_RV crv;
  SFTKDBHandle *dbHandle;

  if (object == NULL((void*)0)) {
      return PR_FALSE0;
  }
  dbHandle = sftk_getDBForTokenObject(object->obj.slot, object->obj.handle);
  template.type = type;
  template.pValue = NULL((void*)0);
  template.ulValueLen = 0;

  crv = sftkdb_GetAttributeValue(dbHandle, object->obj.handle, &template, 1);
  sftk_freeDB(dbHandle);

  /* attribute is bigger than our attribute space buffer, malloc it */
  return (crv == CKR_OK0x00000000UL) ? PR_TRUE1 : PR_FALSE0;
506}

508/*
* return true if object has attribute
*/
511PRBool
512sftk_hasAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
513{
  SFTKAttribute *attribute;
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);

  if (sessObject == NULL((void*)0)) {
      return sftk_hasAttributeToken(sftk_narrowToTokenObject(object), type);
  }

  PR_Lock(sessObject->attributeLock);
  sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize)for ((attribute) = (sessObject->head)[((PRUint32)((type) *
 1791398085) & (sessObject->hashSize - 1))]; (attribute
) != ((void*)0); (attribute) = (attribute)->next) { if ((attribute
)->handle == (type)) { break; } };
  PR_Unlock(sessObject->attributeLock);

  return (PRBool)(attribute != NULL((void*)0));
526}

528/*
* add an attribute to an object
*/
531static void
532sftk_AddAttribute(SFTKObject *object, SFTKAttribute *attribute)
533{
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);

  if (sessObject == NULL((void*)0))
      return;
  PR_Lock(sessObject->attributeLock);
  sftkqueue_add(attribute, attribute->handle,{ int tmp = ((PRUint32)((attribute->handle) * 1791398085) &
 (sessObject->hashSize - 1)); (attribute)->next = (sessObject
->head)[tmp]; (attribute)->prev = ((void*)0); if ((sessObject
->head)[tmp]) (sessObject->head)[tmp]->prev = (attribute
); (sessObject->head)[tmp] = (attribute); }
                sessObject->head, sessObject->hashSize){ int tmp = ((PRUint32)((attribute->handle) * 1791398085) &
 (sessObject->hashSize - 1)); (attribute)->next = (sessObject
->head)[tmp]; (attribute)->prev = ((void*)0); if ((sessObject
->head)[tmp]) (sessObject->head)[tmp]->prev = (attribute
); (sessObject->head)[tmp] = (attribute); };
  PR_Unlock(sessObject->attributeLock);
542}

544/*
* copy an unsigned attribute into a SECItem. Secitem is allocated in
* the specified arena.
*/
548CK_RV
549sftk_Attribute2SSecItem(PLArenaPool *arena, SECItem *item, SFTKObject *object,
                      CK_ATTRIBUTE_TYPE type)
551{
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
  SFTKAttribute *attribute;
  CK_RV crv = CKR_OK0x00000000UL;

  item->data = NULL((void*)0);

  if (sessObject != NULL((void*)0)) {
      PR_Lock(sessObject->attributeLock);
      attribute = sftk_FindAttributeLocked(object, type);
  } else {
      attribute = sftk_FindAttribute(object, type);
  }

  if (attribute == NULL((void*)0)) {
      crv = CKR_TEMPLATE_INCOMPLETE0x000000D0UL;
  } else {
      (void)SECITEM_AllocItemSECITEM_AllocItem_Util(arena, item, attribute->attrib.ulValueLen);
      if (item->data == NULL((void*)0)) {
          crv = CKR_HOST_MEMORY0x00000002UL;
      } else {
          PORT_Memcpymemcpy(item->data, attribute->attrib.pValue, item->len);
      }
  }

  if (sessObject != NULL((void*)0)) {
      PR_Unlock(sessObject->attributeLock);
  } else {
      sftk_FreeAttribute(attribute);
  }
  return crv;
582}

584/*
* fetch multiple attributes into  SECItems. Secitem data is allocated in
* the specified arena.
*/
588CK_RV
589sftk_MultipleAttribute2SecItem(PLArenaPool *arena, SFTKObject *object,
                             SFTKItemTemplate *itemTemplate, int itemTemplateCount)
591{

  CK_RV crv = CKR_OK0x00000000UL;
  CK_ATTRIBUTE templateSpace[SFTK_MAX_ITEM_TEMPLATE10];
  CK_ATTRIBUTE *template;
  SFTKTokenObject *tokObject;
  SFTKDBHandle *dbHandle = NULL((void*)0);
  int i;

  tokObject = sftk_narrowToTokenObject(object);

  /* session objects, just loop through the list */
  if (tokObject == NULL((void*)0)) {
      for (i = 0; i < itemTemplateCount; i++) {
          crv = sftk_Attribute2SecItem(arena, itemTemplate[i].item, object,
                                       itemTemplate[i].type);
          if (crv != CKR_OK0x00000000UL) {
              return crv;
          }
      }
      return CKR_OK0x00000000UL;
  }

  /* don't do any work if none is required */
  if (itemTemplateCount == 0) {
      return CKR_OK0x00000000UL;
  }

  /* don't allocate the template unless we need it */
  if (itemTemplateCount > SFTK_MAX_ITEM_TEMPLATE10) {
      template = PORT_NewArray(CK_ATTRIBUTE, itemTemplateCount)(CK_ATTRIBUTE *)PORT_Alloc_Util(sizeof(CK_ATTRIBUTE) * (itemTemplateCount
));
  } else {
      template = templateSpace;
  }

  if (template == NULL((void*)0)) {
      crv = CKR_HOST_MEMORY0x00000002UL;
      goto loser;
  }

  dbHandle = sftk_getDBForTokenObject(object->slot, object->handle);
  if (dbHandle == NULL((void*)0)) {
      crv = CKR_OBJECT_HANDLE_INVALID0x00000082UL;
      goto loser;
  }

  /* set up the PKCS #11 template */
  for (i = 0; i < itemTemplateCount; i++) {
      template[i].type = itemTemplate[i].type;
      template[i].pValue = NULL((void*)0);
      template[i].ulValueLen = 0;
  }

  /* fetch the attribute lengths */
  crv = sftkdb_GetAttributeValue(dbHandle, object->handle,
                                 template, itemTemplateCount);
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }

  /* allocate space for the attributes */
  for (i = 0; i < itemTemplateCount; i++) {
      template[i].pValue = PORT_ArenaAllocPORT_ArenaAlloc_Util(arena, template[i].ulValueLen);
      if (template[i].pValue == NULL((void*)0)) {
          crv = CKR_HOST_MEMORY0x00000002UL;
          goto loser;
      }
  }

  /* fetch the attributes */
  crv = sftkdb_GetAttributeValue(dbHandle, object->handle,
                                 template, itemTemplateCount);
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }

  /* Fill in the items */
  for (i = 0; i < itemTemplateCount; i++) {
      itemTemplate[i].item->data = template[i].pValue;
      itemTemplate[i].item->len = template[i].ulValueLen;
  }

673loser:
  if (template != templateSpace) {
      PORT_FreePORT_Free_Util(template);
  }
  if (dbHandle) {
      sftk_freeDB(dbHandle);
  }

  return crv;
682}

684/*
* this is only valid for CK_BBOOL type attributes. Return the state
* of that attribute.
*/
688PRBool
689sftk_isTrue(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
690{
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
  SFTKAttribute *attribute;
  PRBool tok = PR_FALSE0;

  /* For a session object read the live single-byte value under the lock
   * rather than copying it out (this is a very hot path); for a token
   * object fall back to a freed copy. */
  if (sessObject != NULL((void*)0)) {
      PR_Lock(sessObject->attributeLock);
      attribute = sftk_FindAttributeLocked(object, type);
  } else {
      attribute = sftk_FindAttribute(object, type);
  }

  if (attribute != NULL((void*)0) && attribute->attrib.pValue != NULL((void*)0)) {
      tok = (PRBool)(*(CK_BBOOL *)attribute->attrib.pValue);
  }

  if (sessObject != NULL((void*)0)) {
      PR_Unlock(sessObject->attributeLock);
  } else {
      sftk_FreeAttribute(attribute);
  }

  return tok;
716}

718static CK_RV
719sftk_forceTokenAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
                       const void *value, unsigned int len)
721{
  CK_ATTRIBUTE attribute;
  SFTKDBHandle *dbHandle = NULL((void*)0);
  SFTKTokenObject *to = sftk_narrowToTokenObject(object);
  CK_RV crv;

  PORT_Assert(to)((to) ? ((void)0) : PR_Assert("to", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 727));
  if (to == NULL((void*)0)) {
      return CKR_DEVICE_ERROR0x00000030UL;
  }

  dbHandle = sftk_getDBForTokenObject(object->slot, object->handle);

  attribute.type = type;
  attribute.pValue = (void *)value;
  attribute.ulValueLen = len;

  crv = sftkdb_SetAttributeValue(dbHandle, object, &attribute, 1);
  sftk_freeDB(dbHandle);
  return crv;
741}

743/*
* force an attribute to a specifc value.
*/
746CK_RV
747sftk_forceAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
                  const void *value, unsigned int len)
749{
  SFTKAttribute *attribute;
  void *att_val = NULL((void*)0);
  PRBool freeData = PR_FALSE0;

  PORT_Assert(object)((object) ? ((void)0) : PR_Assert("object", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 754));
  PORT_Assert(object->refCount)((object->refCount) ? ((void)0) : PR_Assert("object->refCount"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 755
));
  PORT_Assert(object->slot)((object->slot) ? ((void)0) : PR_Assert("object->slot",
 "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 756
));
  if (!object ||
      !object->refCount ||
      !object->slot) {
      return CKR_DEVICE_ERROR0x00000030UL;
  }
  /* validation flags are stored as FIPS indicators,
   * don't send them through the general attribute
   * parsing */
  if (type == CKA_OBJECT_VALIDATION_FLAGS0x0000061eUL) {
      CK_FLAGS validation;
      if (len != sizeof(CK_FLAGS)) {
          return CKR_ATTRIBUTE_VALUE_INVALID0x00000013UL;
      }
      validation = *(CK_FLAGS *)value;
      /* we only understand FIPS currently, don't allow setting
       * other flags */
      if ((validation & ~SFTK_VALIDATION_FIPS_FLAG0x00000001L) != 0) {
          return CKR_ATTRIBUTE_VALUE_INVALID0x00000013UL;
      }
      object->validation_value = validation;
      return CKR_OK0x00000000UL;
  }
  if (sftk_isToken(object->handle)(((object->handle) & 0x80000000L) == 0x80000000L)) {
      return sftk_forceTokenAttribute(object, type, value, len);
  }
  /* After the token/validation dispatch above, this is a session
   * object. Look up and mutate the live node under attributeLock so the
   * (pValue, ulValueLen) pair stays consistent for concurrent readers,
   * which snapshot it under the same lock in sftk_FindAttribute(). */
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
  PORT_Assert(sessObject)((sessObject) ? ((void)0) : PR_Assert("sessObject", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 787));
  if (sessObject == NULL((void*)0)) {
      return CKR_DEVICE_ERROR0x00000030UL;
  }

  PR_Lock(sessObject->attributeLock);
  sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize)for ((attribute) = (sessObject->head)[((PRUint32)((type) *
 1791398085) & (sessObject->hashSize - 1))]; (attribute
) != ((void*)0); (attribute) = (attribute)->next) { if ((attribute
)->handle == (type)) { break; } };
  if (attribute == NULL((void*)0)) {
      PR_Unlock(sessObject->attributeLock);
      return sftk_AddAttributeType(object, type, value, len);
  }

  if (value) {
      if (len <= ATTR_SPACE50) {
          att_val = attribute->space;
      } else {
          att_val = PORT_AllocPORT_Alloc_Util(len);
          freeData = PR_TRUE1;
      }
      if (att_val == NULL((void*)0)) {
          PR_Unlock(sessObject->attributeLock);
          return CKR_HOST_MEMORY0x00000002UL;
      }
      if (attribute->attrib.pValue == att_val) {
          PORT_Memsetmemset(attribute->attrib.pValue, 0,
                      attribute->attrib.ulValueLen);
      }
      PORT_Memcpymemcpy(att_val, value, len);
  }
  if (attribute->attrib.pValue != NULL((void*)0)) {
      if (attribute->attrib.pValue != att_val) {
          PORT_Memsetmemset(attribute->attrib.pValue, 0,
                      attribute->attrib.ulValueLen);
      }
      if (attribute->freeData) {
          PORT_ReleaseAssert(attribute->attrib.pValue != att_val)((attribute->attrib.pValue != att_val) ? ((void)0) : PR_Assert
("attribute->attrib.pValue != att_val", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 822));
          PORT_FreePORT_Free_Util(attribute->attrib.pValue);
      }
      attribute->freeData = PR_FALSE0;
      attribute->attrib.pValue = NULL((void*)0);
      attribute->attrib.ulValueLen = 0;
  }
  if (att_val) {
      attribute->attrib.pValue = att_val;
      attribute->attrib.ulValueLen = len;
      attribute->freeData = freeData;
  }
  PR_Unlock(sessObject->attributeLock);
  return CKR_OK0x00000000UL;
836}

838/*
* decode when a particular attribute may be modified
*  SFTK_NEVER: This attribute must be set at object creation time and
*  can never be modified.
*  SFTK_ONCOPY: This attribute may be modified only when you copy the
*  object.
*  SFTK_SENSITIVE: The CKA_SENSITIVE attribute can only be changed from
*  CK_FALSE to CK_TRUE.
*  SFTK_ALWAYS: This attribute can always be modified.
* Some attributes vary their modification type based on the class of the
*   object.
*/
850SFTKModifyType
851sftk_modifyType(CK_ATTRIBUTE_TYPE type, CK_OBJECT_CLASS inClass)
852{
  /* if we don't know about it, user user defined, always allow modify */
  SFTKModifyType mtype = SFTK_ALWAYS;

  switch (type) {
      /* NEVER */
      case CKA_CLASS0x00000000UL:
      case CKA_CERTIFICATE_TYPE0x00000080UL:
      case CKA_KEY_TYPE0x00000100UL:
      case CKA_MODULUS0x00000120UL:
      case CKA_MODULUS_BITS0x00000121UL:
      case CKA_PUBLIC_EXPONENT0x00000122UL:
      case CKA_PRIVATE_EXPONENT0x00000123UL:
      case CKA_PRIME0x00000130UL:
      case CKA_BASE0x00000132UL:
      case CKA_PRIME_10x00000124UL:
      case CKA_PRIME_20x00000125UL:
      case CKA_EXPONENT_10x00000126UL:
      case CKA_EXPONENT_20x00000127UL:
      case CKA_COEFFICIENT0x00000128UL:
      case CKA_SEED0x00000637UL:
      case CKA_PARAMETER_SET0x0000061dUL:
      case CKA_VALUE_LEN0x00000161UL:
      case CKA_ALWAYS_SENSITIVE0x00000165UL:
      case CKA_NEVER_EXTRACTABLE0x00000164UL:
      case CKA_NSS_DB0xD5A0DB00L:
          mtype = SFTK_NEVER;
          break;

      /* ONCOPY */
      case CKA_TOKEN0x00000001UL:
      case CKA_PRIVATE0x00000002UL:
      case CKA_MODIFIABLE0x00000170UL:
          mtype = SFTK_ONCOPY;
          break;

      /* SENSITIVE */
      case CKA_SENSITIVE0x00000103UL:
      case CKA_EXTRACTABLE0x00000162UL:
          mtype = SFTK_SENSITIVE;
          break;

      /* ALWAYS */
      case CKA_LABEL0x00000003UL:
      case CKA_APPLICATION0x00000010UL:
      case CKA_ID0x00000102UL:
      case CKA_SERIAL_NUMBER0x00000082UL:
      case CKA_START_DATE0x00000110UL:
      case CKA_END_DATE0x00000111UL:
      case CKA_DERIVE0x0000010CUL:
      case CKA_ENCRYPT0x00000104UL:
      case CKA_DECRYPT0x00000105UL:
      case CKA_SIGN0x00000108UL:
      case CKA_VERIFY0x0000010AUL:
      case CKA_SIGN_RECOVER0x00000109UL:
      case CKA_VERIFY_RECOVER0x0000010BUL:
      case CKA_WRAP0x00000106UL:
      case CKA_UNWRAP0x00000107UL:
          mtype = SFTK_ALWAYS;
          break;

      /* DEPENDS ON CLASS */
      case CKA_VALUE0x00000011UL:
          mtype = (inClass == CKO_DATA0x00000000UL) ? SFTK_ALWAYS : SFTK_NEVER;
          break;

      case CKA_SUBPRIME0x00000131UL:
          /* allow the CKA_SUBPRIME to be added to dh private keys */
          mtype = (inClass == CKO_PRIVATE_KEY0x00000003UL) ? SFTK_ALWAYS : SFTK_NEVER;
          break;

      case CKA_SUBJECT0x00000101UL:
          mtype = (inClass == CKO_CERTIFICATE0x00000001UL) ? SFTK_NEVER : SFTK_ALWAYS;
          break;
      default:
          break;
  }
  return mtype;
930}

932/* decode if a particular attribute is sensitive (cannot be read
* back to the user of if the object is set to SENSITIVE) */
934PRBool
935sftk_isSensitive(CK_ATTRIBUTE_TYPE type, CK_OBJECT_CLASS inClass)
936{
  switch (type) {
      /* ALWAYS */
      case CKA_PRIVATE_EXPONENT0x00000123UL:
      case CKA_PRIME_10x00000124UL:
      case CKA_PRIME_20x00000125UL:
      case CKA_EXPONENT_10x00000126UL:
      case CKA_EXPONENT_20x00000127UL:
      case CKA_COEFFICIENT0x00000128UL:
      case CKA_SEED0x00000637UL:
          return PR_TRUE1;

      /* DEPENDS ON CLASS */
      case CKA_VALUE0x00000011UL:
          /* PRIVATE and SECRET KEYS have SENSITIVE values */
          return (PRBool)((inClass == CKO_PRIVATE_KEY0x00000003UL) || (inClass == CKO_SECRET_KEY0x00000004UL));

      default:
          break;
  }
  return PR_FALSE0;
957}

959/*
* copy an attribute into a SECItem. Secitem is allocated in the specified
* arena.
*/
963CK_RV
964sftk_Attribute2SecItem(PLArenaPool *arena, SECItem *item, SFTKObject *object,
                     CK_ATTRIBUTE_TYPE type)
966{
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
  SFTKAttribute *attribute;
  CK_RV crv = CKR_OK0x00000000UL;
  int len;

  if (sessObject != NULL((void*)0)) {
      PR_Lock(sessObject->attributeLock);
      attribute = sftk_FindAttributeLocked(object, type);
  } else {
      attribute = sftk_FindAttribute(object, type);
  }

  if (attribute == NULL((void*)0)) {
      crv = CKR_TEMPLATE_INCOMPLETE0x000000D0UL;
  } else {
      len = attribute->attrib.ulValueLen;
      if (arena) {
          item->data = (unsigned char *)PORT_ArenaAllocPORT_ArenaAlloc_Util(arena, len);
      } else {
          item->data = (unsigned char *)PORT_AllocPORT_Alloc_Util(len);
      }
      if (item->data == NULL((void*)0)) {
          crv = CKR_HOST_MEMORY0x00000002UL;
      } else {
          item->len = len;
          PORT_Memcpymemcpy(item->data, attribute->attrib.pValue, len);
      }
  }

  if (sessObject != NULL((void*)0)) {
      PR_Unlock(sessObject->attributeLock);
  } else {
      sftk_FreeAttribute(attribute);
  }
  return crv;
1002}

1004CK_RV
1005sftk_GetULongAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
                     CK_ULONG *longData)
1007{
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
  SFTKAttribute *attribute;
  CK_RV crv = CKR_OK0x00000000UL;

  /* For a session object read the live value under the lock instead of
   * copying it out; for a token object fall back to a freed copy. */
  if (sessObject != NULL((void*)0)) {
      PR_Lock(sessObject->attributeLock);
      attribute = sftk_FindAttributeLocked(object, type);
  } else {
      attribute = sftk_FindAttribute(object, type);
  }

  if (attribute == NULL((void*)0)) {
      crv = CKR_TEMPLATE_INCOMPLETE0x000000D0UL;
  } else if (attribute->attrib.ulValueLen != sizeof(CK_ULONG)) {
      crv = CKR_ATTRIBUTE_VALUE_INVALID0x00000013UL;
  } else {
      *longData = *(CK_ULONG *)attribute->attrib.pValue;
  }

  if (sessObject != NULL((void*)0)) {
      PR_Unlock(sessObject->attributeLock);
  } else {
      sftk_FreeAttribute(attribute);
  }
  return crv;
1035}

1037CK_RV
1038sftk_ReadAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
                 unsigned char *data, unsigned int maxLen, unsigned int *lenp)
1040{
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
  SFTKAttribute *attribute;
  CK_RV crv = CKR_OK0x00000000UL;

  /* For a session object read the live value under the lock instead of
   * copying it out; for a token object fall back to a freed copy. */
  if (sessObject != NULL((void*)0)) {
      PR_Lock(sessObject->attributeLock);
      attribute = sftk_FindAttributeLocked(object, type);
  } else {
      attribute = sftk_FindAttribute(object, type);
  }

  if (attribute == NULL((void*)0)) {
      crv = CKR_TEMPLATE_INCOMPLETE0x000000D0UL;
  } else {
      *lenp = attribute->attrib.ulValueLen;
      if (*lenp > maxLen) {
          /* normally would be CKR_BUFFER_TOO_SMALL, but
           * it used with internal buffers, so if the value is
           * to long, the original attribute was invalid */
          crv = CKR_ATTRIBUTE_VALUE_INVALID0x00000013UL;
      } else {
          PORT_Memcpymemcpy(data, attribute->attrib.pValue, *lenp);
      }
  }

  if (sessObject != NULL((void*)0)) {
      PR_Unlock(sessObject->attributeLock);
  } else {
      sftk_FreeAttribute(attribute);
  }
  return crv;
1074}

1076void
1077sftk_DeleteAttributeType(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
1078{
  SFTKAttribute *attribute;
  SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);

  if (sessObject == NULL((void*)0)) {
      return;
  }

  /* Find, unlink, and destroy the live node atomically under the lock.
   * Once unlinked from head[] the node is unreachable by any other
   * thread (readers snapshot copies under the same lock), so destroying
   * it here cannot race a concurrent reader or a second deleter. */
  PR_Lock(sessObject->attributeLock);
  sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize)for ((attribute) = (sessObject->head)[((PRUint32)((type) *
 1791398085) & (sessObject->hashSize - 1))]; (attribute
) != ((void*)0); (attribute) = (attribute)->next) { if ((attribute
)->handle == (type)) { break; } };
  if (attribute != NULL((void*)0)) {
      if (sftkqueue_is_queued(attribute, attribute->handle,(((attribute)->next) || ((attribute)->prev) || ((sessObject
->head)[((PRUint32)((attribute->handle) * 1791398085) &
 (sessObject->hashSize - 1))] == (attribute)))
                              sessObject->head, sessObject->hashSize)(((attribute)->next) || ((attribute)->prev) || ((sessObject
->head)[((PRUint32)((attribute->handle) * 1791398085) &
 (sessObject->hashSize - 1))] == (attribute)))) {
          sftkqueue_delete(attribute, attribute->handle,if ((attribute)->next) (attribute)->next->prev = (attribute
)->prev; if ((attribute)->prev) (attribute)->prev->
next = (attribute)->next; else (sessObject->head)[((PRUint32
)((attribute->handle) * 1791398085) & (sessObject->
hashSize - 1))] = ((attribute)->next); (attribute)->next
 = ((void*)0); (attribute)->prev = ((void*)0);
                           sessObject->head, sessObject->hashSize)if ((attribute)->next) (attribute)->next->prev = (attribute
)->prev; if ((attribute)->prev) (attribute)->prev->
next = (attribute)->next; else (sessObject->head)[((PRUint32
)((attribute->handle) * 1791398085) & (sessObject->
hashSize - 1))] = ((attribute)->next); (attribute)->next
 = ((void*)0); (attribute)->prev = ((void*)0);;
      }
      sftk_DestroyAttribute(attribute);
  }
  PR_Unlock(sessObject->attributeLock);
1101}

1103CK_RV
1104sftk_AddAttributeType(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
                    const void *valPtr, CK_ULONG length)
1106{
  SFTKAttribute *attribute;
  attribute = sftk_NewAttribute(object, type, valPtr, length);
  if (attribute == NULL((void*)0)) {
      return CKR_HOST_MEMORY0x00000002UL;
  }
  sftk_AddAttribute(object, attribute);
  return CKR_OK0x00000000UL;
1114}

1116/*
* ******************** Object Utilities *******************************
*/

1120/* must be called holding sftk_tokenKeyLock(slot) */
1121static SECItem *
1122sftk_lookupTokenKeyByHandle(SFTKSlot *slot, CK_OBJECT_HANDLE handle)
1123{
  return (SECItem *)PL_HashTableLookup(slot->tokObjHashTable, (void *)(uintptr_t)handle);
1125}

1127/*
* use the refLock. This operations should be very rare, so the added
* contention on the ref lock should be lower than the overhead of adding
* a new lock. We use separate functions for this just in case I'm wrong.
*/
1132static void
1133sftk_tokenKeyLock(SFTKSlot *slot)
1134{
  SKIP_AFTER_FORK(PR_Lock(slot->objectLock))PR_Lock(slot->objectLock);
1136}

1138static void
1139sftk_tokenKeyUnlock(SFTKSlot *slot)
1140{
  SKIP_AFTER_FORK(PR_Unlock(slot->objectLock))PR_Unlock(slot->objectLock);
1142}

1144static PRIntn
1145sftk_freeHashItem(PLHashEntry *entry, PRIntn index, void *arg)
1146{
  SECItem *item = (SECItem *)entry->value;

  SECITEM_FreeItemSECITEM_FreeItem_Util(item, PR_TRUE1);
  return HT_ENUMERATE_NEXT0;
1151}

1153CK_RV
1154SFTK_ClearTokenKeyHashTable(SFTKSlot *slot)
1155{
  sftk_tokenKeyLock(slot);
  PORT_Assert(!slot->present)((!slot->present) ? ((void)0) : PR_Assert("!slot->present"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1157
));
  PL_HashTableEnumerateEntries(slot->tokObjHashTable, sftk_freeHashItem, NULL((void*)0));
  sftk_tokenKeyUnlock(slot);
  return CKR_OK0x00000000UL;
1161}

1163/* allocation hooks that allow us to recycle old object structures */
1164static SFTKObjectFreeList sessionObjectList = { NULL((void*)0), NULL((void*)0), 0 };
1165static SFTKObjectFreeList tokenObjectList = { NULL((void*)0), NULL((void*)0), 0 };

1167SFTKObject *
1168sftk_GetObjectFromList(PRBool *hasLocks, PRBool optimizeSpace,
                     SFTKObjectFreeList *list, unsigned int hashSize, PRBool isSessionObject)
1170{
  SFTKObject *object;
  int size = 0;

  if (!optimizeSpace) {
      PR_Lock(list->lock);
      object = list->head;
      if (object) {
          list->head = object->next;
          list->count--;
      }
      PR_Unlock(list->lock);
      if (object) {
          /* A live object on the free list means it was destroyed
           * twice; some other thread still holds a pointer to it and
           * will corrupt it if it is handed out again. */
          PORT_ReleaseAssert(object->refCount == 0)((object->refCount == 0) ? ((void)0) : PR_Assert("object->refCount == 0"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1186
));
          object->next = object->prev = NULL((void*)0);
          *hasLocks = PR_TRUE1;
          return object;
      }
  }
  size = isSessionObject ? sizeof(SFTKSessionObject) + hashSize * sizeof(SFTKAttribute *) : sizeof(SFTKTokenObject);

  object = (SFTKObject *)PORT_ZAllocPORT_ZAlloc_Util(size);
  if (isSessionObject && object) {
      ((SFTKSessionObject *)object)->hashSize = hashSize;
  }
  *hasLocks = PR_FALSE0;
  return object;
1200}

1202static void
1203sftk_PutObjectToList(SFTKObject *object, SFTKObjectFreeList *list,
                   PRBool isSessionObject)
1205{

  /* the code below is equivalent to :
   *     optimizeSpace = isSessionObject ? object->optimizeSpace : PR_FALSE;
   * just faster.
   */
  PRBool optimizeSpace = isSessionObject &&
                         ((SFTKSessionObject *)object)->optimizeSpace;
  if (object->refLock && !optimizeSpace) {
      PR_Lock(list->lock);
      if (list->count < MAX_OBJECT_LIST_SIZE800) {
          object->next = list->head;
          list->head = object;
          list->count++;
          PR_Unlock(list->lock);
          return;
      }
      PR_Unlock(list->lock);
  }
  if (isSessionObject) {
      SFTKSessionObject *so = (SFTKSessionObject *)object;
      PR_DestroyLock(so->attributeLock);
      so->attributeLock = NULL((void*)0);
  }
  if (object->refLock) {
      PR_DestroyLock(object->refLock);
      object->refLock = NULL((void*)0);
  }
  PORT_FreePORT_Free_Util(object);
1234}

1236static SFTKObject *
1237sftk_freeObjectData(SFTKObject *object)
1238{
  SFTKObject *next = object->next;

  PORT_FreePORT_Free_Util(object);
  return next;
1243}

1245static void
1246sftk_InitFreeList(SFTKObjectFreeList *list)
1247{
  if (!list->lock) {
      list->lock = PR_NewLock();
  }
1251}

1253void
1254sftk_InitFreeLists(void)
1255{
  sftk_InitFreeList(&sessionObjectList);
  sftk_InitFreeList(&tokenObjectList);
1258}

1260static void
1261sftk_CleanupFreeList(SFTKObjectFreeList *list, PRBool isSessionList)
1262{
  SFTKObject *object;

  if (!list->lock) {
      return;
  }
  SKIP_AFTER_FORK(PR_Lock(list->lock))PR_Lock(list->lock);
  for (object = list->head; object != NULL((void*)0);
       object = sftk_freeObjectData(object)) {
      PR_DestroyLock(object->refLock);
      if (isSessionList) {
          PR_DestroyLock(((SFTKSessionObject *)object)->attributeLock);
      }
  }
  list->count = 0;
  list->head = NULL((void*)0);
  SKIP_AFTER_FORK(PR_Unlock(list->lock))PR_Unlock(list->lock);
  SKIP_AFTER_FORK(PR_DestroyLock(list->lock))PR_DestroyLock(list->lock);
  list->lock = NULL((void*)0);
1281}

1283void
1284sftk_CleanupFreeLists(void)
1285{
  sftk_CleanupFreeList(&sessionObjectList, PR_TRUE1);
  sftk_CleanupFreeList(&tokenObjectList, PR_FALSE0);
1288}

1290/*
* Create a new object
*/
1293SFTKObject *
1294sftk_NewObject(SFTKSlot *slot)
1295{
  SFTKObject *object;
  SFTKSessionObject *sessObject;
  PRBool hasLocks = PR_FALSE0;
  unsigned int i;
  unsigned int hashSize = 0;

  hashSize = (slot->optimizeSpace) ? SPACE_ATTRIBUTE_HASH_SIZE32 : TIME_ATTRIBUTE_HASH_SIZE32;

  object = sftk_GetObjectFromList(&hasLocks, slot->optimizeSpace,
                                  &sessionObjectList, hashSize, PR_TRUE1);
  if (object == NULL((void*)0)) {
      return NULL((void*)0);
  }
  sessObject = (SFTKSessionObject *)object;
  sessObject->nextAttr = 0;

  for (i = 0; i < MAX_OBJS_ATTRS45; i++) {
      sessObject->attrList[i].attrib.pValue = NULL((void*)0);
      sessObject->attrList[i].freeData = PR_FALSE0;
  }
  sessObject->optimizeSpace = slot->optimizeSpace;

  object->handle = 0;
  object->next = object->prev = NULL((void*)0);
  object->slot = slot;
  /* set up the validation flags */
  object->validation_value = 0;
  object->validation_attribute.next = NULL((void*)0);
  object->validation_attribute.prev = NULL((void*)0);
  object->validation_attribute.freeAttr = PR_FALSE0;
  object->validation_attribute.freeData = PR_FALSE0;
  object->validation_attribute.handle = CKA_OBJECT_VALIDATION_FLAGS0x0000061eUL;
  object->validation_attribute.attrib.type = CKA_OBJECT_VALIDATION_FLAGS0x0000061eUL;
  object->validation_attribute.attrib.pValue = &object->validation_value;
  object->validation_attribute.attrib.ulValueLen = sizeof(object->validation_value);
  /* initialize the FIPS flag properly */
  sftk_setFIPS(object, sftk_isFIPS(slot->slotID)(((slot->slotID) == 3) || ((slot->slotID) >= 101)));
  object->source = SFTK_SOURCE_DEFAULT;

  object->refCount = 1;
  object->type = SFTK_SESSION_OBJECT_TYPE0xFFFFFFFFU;
  sessObject->sessionList.next = NULL((void*)0);
  sessObject->sessionList.prev = NULL((void*)0);
  sessObject->sessionList.parent = object;
  sessObject->session = NULL((void*)0);
  sessObject->wasDerived = PR_FALSE0;
  if (!hasLocks)
      object->refLock = PR_NewLock();
  if (object->refLock == NULL((void*)0)) {
      PORT_FreePORT_Free_Util(object);
      return NULL((void*)0);
  }
  if (!hasLocks)
      sessObject->attributeLock = PR_NewLock();
  if (sessObject->attributeLock == NULL((void*)0)) {
      PR_DestroyLock(object->refLock);
      PORT_FreePORT_Free_Util(object);
      return NULL((void*)0);
  }
  for (i = 0; i < sessObject->hashSize; i++) {
      sessObject->head[i] = NULL((void*)0);
  }
  object->objectInfo = NULL((void*)0);
  object->infoFree = NULL((void*)0);
  return object;
1361}

1363static CK_RV
1364sftk_DestroySessionObjectData(SFTKSessionObject *so)
1365{
  int i;

  for (i = 0; i < MAX_OBJS_ATTRS45; i++) {
      unsigned char *value = so->attrList[i].attrib.pValue;
      if (value) {
          /* An attribute value lives in the attribute's inline space
           * unless the attribute owns a heap allocation for it. Anything
           * else means this object was already destroyed and its memory
           * reused; abort rather than zeroize through a wild pointer. */
          PORT_ReleaseAssert(so->attrList[i].freeData ||((so->attrList[i].freeData || (value == so->attrList[i]
.space && so->attrList[i].attrib.ulValueLen <= 50
)) ? ((void)0) : PR_Assert("so->attrList[i].freeData || (value == so->attrList[i].space && so->attrList[i].attrib.ulValueLen <= ATTR_SPACE)"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1377
))
                             (value == so->attrList[i].space &&((so->attrList[i].freeData || (value == so->attrList[i]
.space && so->attrList[i].attrib.ulValueLen <= 50
)) ? ((void)0) : PR_Assert("so->attrList[i].freeData || (value == so->attrList[i].space && so->attrList[i].attrib.ulValueLen <= ATTR_SPACE)"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1377
))
                              so->attrList[i].attrib.ulValueLen <= ATTR_SPACE))((so->attrList[i].freeData || (value == so->attrList[i]
.space && so->attrList[i].attrib.ulValueLen <= 50
)) ? ((void)0) : PR_Assert("so->attrList[i].freeData || (value == so->attrList[i].space && so->attrList[i].attrib.ulValueLen <= ATTR_SPACE)"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1377
));
          PORT_Memsetmemset(value, 0, so->attrList[i].attrib.ulValueLen);
          if (so->attrList[i].freeData) {
              PORT_FreePORT_Free_Util(value);
          }
          so->attrList[i].attrib.pValue = NULL((void*)0);
          so->attrList[i].attrib.ulValueLen = 0;
          so->attrList[i].freeData = PR_FALSE0;
      }
  }
  /*  PR_DestroyLock(so->attributeLock);*/
  return CKR_OK0x00000000UL;
1389}

1391/*
* free all the data associated with an object. Object reference count must
* be 'zero'.
*/
1395static CK_RV
1396sftk_DestroyObject(SFTKObject *object)
1397{
  CK_RV crv = CKR_OK0x00000000UL;
  SFTKSessionObject *so = sftk_narrowToSessionObject(object);
  SFTKTokenObject *to = sftk_narrowToTokenObject(object);

  PORT_Assert(object->refCount == 0)((object->refCount == 0) ? ((void)0) : PR_Assert("object->refCount == 0"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1402
));

  /* delete the database value */
  if (to) {
      if (to->dbKey.data) {
          PORT_FreePORT_Free_Util(to->dbKey.data);
          to->dbKey.data = NULL((void*)0);
      }
  }
  if (so) {
      sftk_DestroySessionObjectData(so);
  }
  if (object->objectInfo) {
      (*object->infoFree)(object->objectInfo);
      object->objectInfo = NULL((void*)0);
      object->infoFree = NULL((void*)0);
  }
  if (so) {
      sftk_PutObjectToList(object, &sessionObjectList, PR_TRUE1);
  } else {
      sftk_PutObjectToList(object, &tokenObjectList, PR_FALSE0);
  }
  return crv;
1425}

1427void
1428sftk_ReferenceObject(SFTKObject *object)
1429{
  PR_Lock(object->refLock);
  /* A zero count means this object has already been destroyed; abort
   * before the new reference is used to operate on freed memory. */
  PORT_ReleaseAssert(object->refCount > 0)((object->refCount > 0) ? ((void)0) : PR_Assert("object->refCount > 0"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1433
));
  object->refCount++;
  PR_Unlock(object->refLock);
1436}

1438static SFTKObject *
1439sftk_ObjectFromHandleOnSlot(CK_OBJECT_HANDLE handle, SFTKSlot *slot)
1440{
  SFTKObject *object;
  PRUint32 index = sftk_hash(handle, slot->sessObjHashSize)((PRUint32)((handle) * 1791398085) & (slot->sessObjHashSize
 - 1));

  if (sftk_isToken(handle)(((handle) & 0x80000000L) == 0x80000000L)) {
      return sftk_NewTokenObject(slot, NULL((void*)0), handle);
  }

  PR_Lock(slot->objectLock);
  sftkqueue_find2(object, handle, index, slot->sessObjHashTable)for ((object) = (slot->sessObjHashTable)[index]; (object) !=
 ((void*)0); (object) = (object)->next) { if ((object)->
handle == (handle)) { break; } };
  if (object) {
      sftk_ReferenceObject(object);
  }
  PR_Unlock(slot->objectLock);

  return (object);
1456}
1457/*
* look up and object structure from a handle. OBJECT_Handles only make
* sense in terms of a given session.  make a reference to that object
* structure returned.
*/
1462SFTKObject *
1463sftk_ObjectFromHandle(CK_OBJECT_HANDLE handle, SFTKSession *session)
1464{
  SFTKSlot *slot = sftk_SlotFromSession(session)((session)->slot);

  return sftk_ObjectFromHandleOnSlot(handle, slot);
1468}

1470/*
* release a reference to an object handle
*/
1473SFTKFreeStatus
1474sftk_FreeObject(SFTKObject *object)
1475{
  PRBool destroy = PR_FALSE0;
  CK_RV crv;

  PR_Lock(object->refLock);
  /* A zero count means this object has already been destroyed. Abort,
   * like an allocator that detects a double free, rather than tear the
   * object down a second time. */
  PORT_ReleaseAssert(object->refCount > 0)((object->refCount > 0) ? ((void)0) : PR_Assert("object->refCount > 0"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1483
));
  if (object->refCount == 1)
      destroy = PR_TRUE1;
  object->refCount--;
  PR_Unlock(object->refLock);

  if (destroy) {
      crv = sftk_DestroyObject(object);
      if (crv != CKR_OK0x00000000UL) {
          return SFTK_DestroyFailure;
      }
      return SFTK_Destroyed;
  }
  return SFTK_Busy;
1497}

1499/* find the next available object handle that isn't currently in use */
1500/* NOTE: This function could loop forever if we've exhausted all
* 3^31-1 handles. This is highly unlikely (NSS has been running for
* decades with this code) uless we start increasing the size of the
* SFTK_TOKEN_MASK (which is just the high bit currently). */
1504CK_OBJECT_HANDLE
1505sftk_getNextHandle(SFTKSlot *slot)
1506{
  CK_OBJECT_HANDLE handle;
  SFTKObject *duplicateObject = NULL((void*)0);
  do {
      PRUint32 wrappedAround;

      duplicateObject = NULL((void*)0);
      PR_Lock(slot->objectLock);
      wrappedAround = slot->sessionObjectHandleCount & SFTK_TOKEN_MASK0x80000000L;
      handle = slot->sessionObjectHandleCount & ~SFTK_TOKEN_MASK0x80000000L;
      if (!handle) /* don't allow zero handle */
          handle = NSC_MIN_SESSION_OBJECT_HANDLE1U;
      slot->sessionObjectHandleCount = (handle + 1U) | wrappedAround;
      /* Is there already a session object with this handle? */
      if (wrappedAround) {
          sftkqueue_find(duplicateObject, handle, slot->sessObjHashTable,for ((duplicateObject) = (slot->sessObjHashTable)[((PRUint32
)((handle) * 1791398085) & (slot->sessObjHashSize - 1)
)]; (duplicateObject) != ((void*)0); (duplicateObject) = (duplicateObject
)->next) { if ((duplicateObject)->handle == (handle)) {
 break; } }
                         slot->sessObjHashSize)for ((duplicateObject) = (slot->sessObjHashTable)[((PRUint32
)((handle) * 1791398085) & (slot->sessObjHashSize - 1)
)]; (duplicateObject) != ((void*)0); (duplicateObject) = (duplicateObject
)->next) { if ((duplicateObject)->handle == (handle)) {
 break; } };
      }
      PR_Unlock(slot->objectLock);
  } while (duplicateObject != NULL((void*)0));
  return handle;
1527}

1529/*
* Claim the right to remove a session object from the slot's object hash.
* Must be called with slot->objectLock held.
*
* Several threads can reach the same object: handles are slot-global, so any
* session can resolve one through sftk_ObjectFromHandle, and
* sftk_ClearSession claims removals too when the owning session is closed.
* Only the thread that finds the object still queued unlinks it; without that,
* each would unlink again and drop the queues' reference a second time.
*
* Returns PR_TRUE if this caller owns the removal, and with it the reference
* the queues held. Drop that reference with sftk_FreeObject() after releasing
* slot->objectLock.
*/
1543static PRBool
1544sftk_ClaimObjectRemovalLocked(SFTKSlot *slot, SFTKObject *object)
1545{
  PRUint32 index = sftk_hash(object->handle, slot->sessObjHashSize)((PRUint32)((object->handle) * 1791398085) & (slot->
sessObjHashSize - 1));

  if (!object->next && !object->prev &&
      slot->sessObjHashTable[index] != object) {
      return PR_FALSE0;
  }
  sftkqueue_delete2(object, object->handle, index, slot->sessObjHashTable)if ((object)->next) (object)->next->prev = (object)->
prev; if ((object)->prev) (object)->prev->next = (object
)->next; else (slot->sessObjHashTable)[index] = ((object
)->next);;
  /* sftkqueue_delete2 patches the neighbours but leaves object->next/prev
   * pointing at them. Clear them here so the next thread to take the lock
   * sees an unqueued object and does not re-claim the removal. */
  sftkqueue_clear_deleted_element(object)(object)->next = ((void*)0); (object)->prev = ((void*)0
);;
  return PR_TRUE1;
1558}

1560/*
* add an object to the slot's object hash and to its session's object list
*/
1563void
1564sftk_AddObject(SFTKSession *session, SFTKObject *object)
1565{
  SFTKSlot *slot = sftk_SlotFromSession(session)((session)->slot);
  SFTKSessionObject *so = sftk_narrowToSessionObject(object);
  PRUint32 index = sftk_hash(object->handle, slot->sessObjHashSize)((PRUint32)((object->handle) * 1791398085) & (slot->
sessObjHashSize - 1));

  /* the reference the queues hold, taken before the object is reachable */
  sftk_ReferenceObject(object);

  /* Both queues are linked under slot->objectLock in one critical section.
   * That gives the invariant the teardown paths depend on: a session object
   * is on its owning session's list if and only if it is in the slot's
   * object hash. See sftk_DeleteObject(). */
  sftkqueue_init_element(object)(object)->prev = ((void*)0);;
  PR_Lock(slot->objectLock);
  if (so) {
      so->session = session;
      sftkqueue_add(&so->sessionList, 0, session->objects, 0){ int tmp = ((PRUint32)((0) * 1791398085) & (0 - 1)); (&
so->sessionList)->next = (session->objects)[tmp]; (&
so->sessionList)->prev = ((void*)0); if ((session->objects
)[tmp]) (session->objects)[tmp]->prev = (&so->sessionList
); (session->objects)[tmp] = (&so->sessionList); };
  }
  sftkqueue_add2(object, object->handle, index, slot->sessObjHashTable){ (object)->next = (slot->sessObjHashTable)[index]; if (
(slot->sessObjHashTable)[index]) (slot->sessObjHashTable
)[index]->prev = (object); (slot->sessObjHashTable)[index
] = (object); };
  PR_Unlock(slot->objectLock);
1585}

1587/*
* delete an object from a slot and session queue
*/
1590CK_RV
1591sftk_DeleteObject(SFTKSession *session, SFTKObject *object)
1592{
  SFTKSlot *slot = sftk_SlotFromSession(session)((session)->slot);
  SFTKSessionObject *so = sftk_narrowToSessionObject(object);
  CK_RV crv = CKR_OK0x00000000UL;

  /* Handle Token case */
  if (so && so->session) {
      PRBool ownsRemove;

      /* so->session is the session that created the object; it need not be
       * the caller's session, and we hold no reference on it. Winning the
       * claim is what makes it safe to touch: the object was still in the
       * slot hash, so by the invariant in sftk_AddObject() it is still on
       * so->session's list, so sftk_ClearSession() has not run for that
       * session and the session has not been freed. */
      PR_Lock(slot->objectLock);
      ownsRemove = sftk_ClaimObjectRemovalLocked(slot, object);
      if (ownsRemove) {
          PORT_Assert(sftkqueue_is_queued(&so->sessionList, 0,(((((&so->sessionList)->next) || ((&so->sessionList
)->prev) || ((so->session->objects)[((PRUint32)((0) *
 1791398085) & (0 - 1))] == (&so->sessionList)))) ?
 ((void)0) : PR_Assert("sftkqueue_is_queued(&so->sessionList, 0, so->session->objects, 0)"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1611
))
                                          so->session->objects, 0))(((((&so->sessionList)->next) || ((&so->sessionList
)->prev) || ((so->session->objects)[((PRUint32)((0) *
 1791398085) & (0 - 1))] == (&so->sessionList)))) ?
 ((void)0) : PR_Assert("sftkqueue_is_queued(&so->sessionList, 0, so->session->objects, 0)"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 1611
));
          sftkqueue_delete(&so->sessionList, 0, so->session->objects, 0)if ((&so->sessionList)->next) (&so->sessionList
)->next->prev = (&so->sessionList)->prev; if (
(&so->sessionList)->prev) (&so->sessionList)
->prev->next = (&so->sessionList)->next; else
 (so->session->objects)[((PRUint32)((0) * 1791398085) &
 (0 - 1))] = ((&so->sessionList)->next); (&so->
sessionList)->next = ((void*)0); (&so->sessionList)
->prev = ((void*)0);;
      }
      PR_Unlock(slot->objectLock);

      if (ownsRemove) {
          sftk_FreeObject(object); /* drop the queues' reference */
      }
  } else {
      SFTKDBHandle *handle = sftk_getDBForTokenObject(slot, object->handle);
1621#ifdef DEBUG1
      SFTKTokenObject *to = sftk_narrowToTokenObject(object);
      PORT_Assert(to)((to) ? ((void)0) : PR_Assert("to", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 1623));
1624#endif
      crv = sftkdb_DestroyObject(handle, object->handle, object->objclass);
      sftk_freeDB(handle);
  }
  return crv;
1629}

1631/*
* Token objects don't explicitly store their attributes, so we need to know
* what attributes make up a particular token object before we can copy it.
* below are the tables by object type.
*/
1636static const CK_ATTRIBUTE_TYPE commonAttrs[] = {
  CKA_CLASS0x00000000UL, CKA_TOKEN0x00000001UL, CKA_PRIVATE0x00000002UL, CKA_LABEL0x00000003UL, CKA_MODIFIABLE0x00000170UL
1638};
1639static const CK_ULONG commonAttrsCount =
  sizeof(commonAttrs) / sizeof(commonAttrs[0]);

1642static const CK_ATTRIBUTE_TYPE commonKeyAttrs[] = {
  CKA_ID0x00000102UL, CKA_START_DATE0x00000110UL, CKA_END_DATE0x00000111UL, CKA_DERIVE0x0000010CUL, CKA_LOCAL0x00000163UL, CKA_KEY_TYPE0x00000100UL
1644};
1645static const CK_ULONG commonKeyAttrsCount =
  sizeof(commonKeyAttrs) / sizeof(commonKeyAttrs[0]);

1648static const CK_ATTRIBUTE_TYPE secretKeyAttrs[] = {
  CKA_SENSITIVE0x00000103UL, CKA_EXTRACTABLE0x00000162UL, CKA_ENCRYPT0x00000104UL, CKA_DECRYPT0x00000105UL, CKA_SIGN0x00000108UL,
  CKA_VERIFY0x0000010AUL, CKA_WRAP0x00000106UL, CKA_UNWRAP0x00000107UL, CKA_VALUE0x00000011UL
1651};
1652static const CK_ULONG secretKeyAttrsCount =
  sizeof(secretKeyAttrs) / sizeof(secretKeyAttrs[0]);

1655static const CK_ATTRIBUTE_TYPE commonPubKeyAttrs[] = {
  CKA_ENCRYPT0x00000104UL, CKA_VERIFY0x0000010AUL, CKA_VERIFY_RECOVER0x0000010BUL, CKA_WRAP0x00000106UL, CKA_SUBJECT0x00000101UL
1657};
1658static const CK_ULONG commonPubKeyAttrsCount =
  sizeof(commonPubKeyAttrs) / sizeof(commonPubKeyAttrs[0]);

1661static const CK_ATTRIBUTE_TYPE rsaPubKeyAttrs[] = {
  CKA_MODULUS0x00000120UL, CKA_PUBLIC_EXPONENT0x00000122UL
1663};
1664static const CK_ULONG rsaPubKeyAttrsCount =
  sizeof(rsaPubKeyAttrs) / sizeof(rsaPubKeyAttrs[0]);

1667static const CK_ATTRIBUTE_TYPE dsaPubKeyAttrs[] = {
  CKA_SUBPRIME0x00000131UL, CKA_PRIME0x00000130UL, CKA_BASE0x00000132UL, CKA_VALUE0x00000011UL
1669};
1670static const CK_ULONG dsaPubKeyAttrsCount =
  sizeof(dsaPubKeyAttrs) / sizeof(dsaPubKeyAttrs[0]);

1673static const CK_ATTRIBUTE_TYPE dhPubKeyAttrs[] = {
  CKA_PRIME0x00000130UL, CKA_BASE0x00000132UL, CKA_VALUE0x00000011UL
1675};
1676static const CK_ULONG dhPubKeyAttrsCount =
  sizeof(dhPubKeyAttrs) / sizeof(dhPubKeyAttrs[0]);
1678static const CK_ATTRIBUTE_TYPE ecPubKeyAttrs[] = {
  CKA_EC_PARAMS0x00000180UL, CKA_EC_POINT0x00000181UL
1680};
1681static const CK_ULONG ecPubKeyAttrsCount =
  sizeof(ecPubKeyAttrs) / sizeof(ecPubKeyAttrs[0]);

1684static const CK_ATTRIBUTE_TYPE mldsaPubKeyAttrs[] = {
  CKA_PARAMETER_SET0x0000061dUL, CKA_VALUE0x00000011UL
1686};
1687static const CK_ULONG mldsaPubKeyAttrsCount = PR_ARRAY_SIZE(mldsaPubKeyAttrs)(sizeof(mldsaPubKeyAttrs) / sizeof((mldsaPubKeyAttrs)[0]));

1689/* the vendor ML-KEM key types carry CKA_NSS_PARAMETER_SET rather than
* CKA_PARAMETER_SET; list both and let the missing one be skipped */
1691static const CK_ATTRIBUTE_TYPE mlkemPubKeyAttrs[] = {
  CKA_PARAMETER_SET0x0000061dUL, CKA_NSS_PARAMETER_SET((0x80000000UL | 0x4E534350) + 40), CKA_VALUE0x00000011UL
1693};
1694static const CK_ULONG mlkemPubKeyAttrsCount = PR_ARRAY_SIZE(mlkemPubKeyAttrs)(sizeof(mlkemPubKeyAttrs) / sizeof((mlkemPubKeyAttrs)[0]));

1696static const CK_ATTRIBUTE_TYPE commonPrivKeyAttrs[] = {
  CKA_DECRYPT0x00000105UL, CKA_SIGN0x00000108UL, CKA_SIGN_RECOVER0x00000109UL, CKA_UNWRAP0x00000107UL, CKA_SUBJECT0x00000101UL,
  CKA_SENSITIVE0x00000103UL, CKA_EXTRACTABLE0x00000162UL, CKA_NSS_DB0xD5A0DB00L, CKA_PUBLIC_KEY_INFO0x00000129UL
1699};
1700static const CK_ULONG commonPrivKeyAttrsCount =
  sizeof(commonPrivKeyAttrs) / sizeof(commonPrivKeyAttrs[0]);

1703static const CK_ATTRIBUTE_TYPE rsaPrivKeyAttrs[] = {
  CKA_MODULUS0x00000120UL, CKA_PUBLIC_EXPONENT0x00000122UL, CKA_PRIVATE_EXPONENT0x00000123UL,
  CKA_PRIME_10x00000124UL, CKA_PRIME_20x00000125UL, CKA_EXPONENT_10x00000126UL, CKA_EXPONENT_20x00000127UL, CKA_COEFFICIENT0x00000128UL
1706};
1707static const CK_ULONG rsaPrivKeyAttrsCount =
  sizeof(rsaPrivKeyAttrs) / sizeof(rsaPrivKeyAttrs[0]);

1710static const CK_ATTRIBUTE_TYPE dsaPrivKeyAttrs[] = {
  CKA_SUBPRIME0x00000131UL, CKA_PRIME0x00000130UL, CKA_BASE0x00000132UL, CKA_VALUE0x00000011UL
1712};
1713static const CK_ULONG dsaPrivKeyAttrsCount =
  sizeof(dsaPrivKeyAttrs) / sizeof(dsaPrivKeyAttrs[0]);

1716static const CK_ATTRIBUTE_TYPE dhPrivKeyAttrs[] = {
  CKA_PRIME0x00000130UL, CKA_BASE0x00000132UL, CKA_VALUE0x00000011UL
1718};
1719static const CK_ULONG dhPrivKeyAttrsCount =
  sizeof(dhPrivKeyAttrs) / sizeof(dhPrivKeyAttrs[0]);
1721static const CK_ATTRIBUTE_TYPE ecPrivKeyAttrs[] = {
  CKA_EC_PARAMS0x00000180UL, CKA_VALUE0x00000011UL
1723};
1724static const CK_ULONG ecPrivKeyAttrsCount =
  sizeof(ecPrivKeyAttrs) / sizeof(ecPrivKeyAttrs[0]);

1727static const CK_ATTRIBUTE_TYPE mldsaPrivKeyAttrs[] = {
  CKA_PARAMETER_SET0x0000061dUL, CKA_VALUE0x00000011UL, CKA_SEED0x00000637UL
1729};
1730static const CK_ULONG mldsaPrivKeyAttrsCount = PR_ARRAY_SIZE(mldsaPrivKeyAttrs)(sizeof(mldsaPrivKeyAttrs) / sizeof((mldsaPrivKeyAttrs)[0]));

1732static const CK_ATTRIBUTE_TYPE mlkemPrivKeyAttrs[] = {
  CKA_PARAMETER_SET0x0000061dUL, CKA_NSS_PARAMETER_SET((0x80000000UL | 0x4E534350) + 40), CKA_VALUE0x00000011UL, CKA_SEED0x00000637UL
1734};
1735static const CK_ULONG mlkemPrivKeyAttrsCount = PR_ARRAY_SIZE(mlkemPrivKeyAttrs)(sizeof(mlkemPrivKeyAttrs) / sizeof((mlkemPrivKeyAttrs)[0]));

1737static const CK_ATTRIBUTE_TYPE certAttrs[] = {
  CKA_CERTIFICATE_TYPE0x00000080UL, CKA_VALUE0x00000011UL, CKA_SUBJECT0x00000101UL, CKA_ISSUER0x00000081UL, CKA_SERIAL_NUMBER0x00000082UL
1739};
1740static const CK_ULONG certAttrsCount =
  sizeof(certAttrs) / sizeof(certAttrs[0]);

1743static const CK_ATTRIBUTE_TYPE nssTrustAttrs[] = {
  CKA_ISSUER0x00000081UL, CKA_SERIAL_NUMBER0x00000082UL, CKA_NSS_CERT_SHA1_HASH(((0x80000000UL | 0x4E534350) + 0x2000) + 100),
  CKA_NSS_CERT_MD5_HASH(((0x80000000UL | 0x4E534350) + 0x2000) + 101), CKA_NSS_TRUST_SERVER_AUTH(((0x80000000UL | 0x4E534350) + 0x2000) + 8), CKA_NSS_TRUST_CLIENT_AUTH(((0x80000000UL | 0x4E534350) + 0x2000) + 9),
  CKA_NSS_TRUST_EMAIL_PROTECTION(((0x80000000UL | 0x4E534350) + 0x2000) + 11), CKA_NSS_TRUST_CODE_SIGNING(((0x80000000UL | 0x4E534350) + 0x2000) + 10),
  CKA_NSS_TRUST_STEP_UP_APPROVED(((0x80000000UL | 0x4E534350) + 0x2000) + 16)
1748};
1749static const CK_ULONG nssTrustAttrsCount =
  sizeof(nssTrustAttrs) / sizeof(nssTrustAttrs[0]);

1752static const CK_ATTRIBUTE_TYPE trustAttrs[] = {
  CKA_ISSUER0x00000081UL, CKA_SERIAL_NUMBER0x00000082UL, CKA_HASH_OF_CERTIFICATE0x00000635UL,
  CKA_NAME_HASH_ALGORITHM0x0000008cUL, CKA_PKCS_TRUST_SERVER_AUTH0x0000062cUL,
  CKA_PKCS_TRUST_CLIENT_AUTH0x0000062dUL, CKA_PKCS_TRUST_EMAIL_PROTECTION0x0000062fUL,
  CKA_PKCS_TRUST_CODE_SIGNING0x0000062eUL
1757};
1758static const CK_ULONG trustAttrsCount =
  sizeof(trustAttrs) / sizeof(trustAttrs[0]);

1761static const CK_ATTRIBUTE_TYPE smimeAttrs[] = {
  CKA_SUBJECT0x00000101UL, CKA_NSS_EMAIL((0x80000000UL | 0x4E534350) + 2), CKA_NSS_SMIME_TIMESTAMP((0x80000000UL | 0x4E534350) + 4), CKA_VALUE0x00000011UL
1763};
1764static const CK_ULONG smimeAttrsCount =
  sizeof(smimeAttrs) / sizeof(smimeAttrs[0]);

1767static const CK_ATTRIBUTE_TYPE crlAttrs[] = {
  CKA_SUBJECT0x00000101UL, CKA_VALUE0x00000011UL, CKA_NSS_URL((0x80000000UL | 0x4E534350) + 1), CKA_NSS_KRL((0x80000000UL | 0x4E534350) + 8)
1769};
1770static const CK_ULONG crlAttrsCount =
  sizeof(crlAttrs) / sizeof(crlAttrs[0]);

1773/* copy an object based on it's table */
1774CK_RV
1775stfk_CopyTokenAttributes(SFTKObject *destObject, SFTKTokenObject *src_to,
                       const CK_ATTRIBUTE_TYPE *attrArray, CK_ULONG attrCount)
1777{
  SFTKAttribute *attribute;
  SFTKAttribute *newAttribute;
  CK_RV crv = CKR_OK0x00000000UL;
  unsigned int i;

  for (i = 0; i < attrCount; i++) {
      if (!sftk_hasAttribute(destObject, attrArray[i])) {
          attribute = sftk_FindAttribute(&src_to->obj, attrArray[i]);
          if (!attribute) {
              continue; /* return CKR_ATTRIBUTE_VALUE_INVALID; */
          }
          /* we need to copy the attribute since each attribute
           * only has one set of link list pointers */
          newAttribute = sftk_NewAttribute(destObject,
                                           sftk_attr_expand(&attribute->attrib)(&attribute->attrib)->type, (&attribute->attrib
)->pValue, (&attribute->attrib)->ulValueLen);
          sftk_FreeAttribute(attribute); /* free the old attribute */
          if (!newAttribute) {
              return CKR_HOST_MEMORY0x00000002UL;
          }
          sftk_AddAttribute(destObject, newAttribute);
      }
  }
  return crv;
1801}

1803CK_RV
1804stfk_CopyTokenPrivateKey(SFTKObject *destObject, SFTKTokenObject *src_to)
1805{
  CK_RV crv;
  CK_KEY_TYPE key_type;
  SFTKAttribute *attribute;

  /* copy the common attributes for all keys first */
  crv = stfk_CopyTokenAttributes(destObject, src_to, commonKeyAttrs,
                                 commonKeyAttrsCount);
  if (crv != CKR_OK0x00000000UL) {
      goto fail;
  }
  /* copy the common attributes for all private keys next */
  crv = stfk_CopyTokenAttributes(destObject, src_to, commonPrivKeyAttrs,
                                 commonPrivKeyAttrsCount);
  if (crv != CKR_OK0x00000000UL) {
      goto fail;
  }
  attribute = sftk_FindAttribute(&src_to->obj, CKA_KEY_TYPE0x00000100UL);
  PORT_Assert(attribute)((attribute) ? ((void)0) : PR_Assert("attribute", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 1823)); /* if it wasn't here, ww should have failed
                           * copying the common attributes */
  if (!attribute) {
      /* OK, so CKR_ATTRIBUTE_VALUE_INVALID is the immediate error, but
       * the fact is, the only reason we couldn't get the attribute would
       * be a memory error or database error (an error in the 'device').
       * if we have a database error code, we could return it here */
      crv = CKR_DEVICE_ERROR0x00000030UL;
      goto fail;
  }
  key_type = *(CK_KEY_TYPE *)attribute->attrib.pValue;
  sftk_FreeAttribute(attribute);

  /* finally copy the attributes for various private key types */
  switch (key_type) {
      case CKK_RSA0x00000000UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, rsaPrivKeyAttrs,
                                         rsaPrivKeyAttrsCount);
          break;
      case CKK_DSA0x00000001UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, dsaPrivKeyAttrs,
                                         dsaPrivKeyAttrsCount);
          break;
      case CKK_ML_DSA0x0000004aUL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, mldsaPrivKeyAttrs,
                                         mldsaPrivKeyAttrsCount);
          break;
      case CKK_NSS_ML_KEM((0x80000000UL | 0x4E534350) + 6):
      case CKK_ML_KEM0x00000049UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, mlkemPrivKeyAttrs,
                                         mlkemPrivKeyAttrsCount);
          break;
      case CKK_DH0x00000002UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, dhPrivKeyAttrs,
                                         dhPrivKeyAttrsCount);
          break;
      case CKK_EC0x00000003UL:
      case CKK_EC_EDWARDS0x00000040UL:
      case CKK_EC_MONTGOMERY0x00000041UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, ecPrivKeyAttrs,
                                         ecPrivKeyAttrsCount);
          break;
      default:
          crv = CKR_DEVICE_ERROR0x00000030UL; /* shouldn't happen unless we store more types
                                   * of token keys into our database. */
  }
1869fail:
  return crv;
1871}

1873CK_RV
1874stfk_CopyTokenPublicKey(SFTKObject *destObject, SFTKTokenObject *src_to)
1875{
  CK_RV crv;
  CK_KEY_TYPE key_type;
  SFTKAttribute *attribute;

  /* copy the common attributes for all keys first */
  crv = stfk_CopyTokenAttributes(destObject, src_to, commonKeyAttrs,
                                 commonKeyAttrsCount);
  if (crv != CKR_OK0x00000000UL) {
      goto fail;
  }

  /* copy the common attributes for all public keys next */
  crv = stfk_CopyTokenAttributes(destObject, src_to, commonPubKeyAttrs,
                                 commonPubKeyAttrsCount);
  if (crv != CKR_OK0x00000000UL) {
      goto fail;
  }
  attribute = sftk_FindAttribute(&src_to->obj, CKA_KEY_TYPE0x00000100UL);
  PORT_Assert(attribute)((attribute) ? ((void)0) : PR_Assert("attribute", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 1894)); /* if it wasn't here, ww should have failed
                           * copying the common attributes */
  if (!attribute) {
      /* OK, so CKR_ATTRIBUTE_VALUE_INVALID is the immediate error, but
       * the fact is, the only reason we couldn't get the attribute would
       * be a memory error or database error (an error in the 'device').
       * if we have a database error code, we could return it here */
      crv = CKR_DEVICE_ERROR0x00000030UL;
      goto fail;
  }
  key_type = *(CK_KEY_TYPE *)attribute->attrib.pValue;
  sftk_FreeAttribute(attribute);

  /* finally copy the attributes for various public key types */
  switch (key_type) {
      case CKK_RSA0x00000000UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, rsaPubKeyAttrs,
                                         rsaPubKeyAttrsCount);
          break;
      case CKK_DSA0x00000001UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, dsaPubKeyAttrs,
                                         dsaPubKeyAttrsCount);
          break;
      case CKK_ML_DSA0x0000004aUL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, mldsaPubKeyAttrs,
                                         mldsaPubKeyAttrsCount);
          break;
      case CKK_NSS_ML_KEM((0x80000000UL | 0x4E534350) + 6):
      case CKK_ML_KEM0x00000049UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, mlkemPubKeyAttrs,
                                         mlkemPubKeyAttrsCount);
          break;
      case CKK_DH0x00000002UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, dhPubKeyAttrs,
                                         dhPubKeyAttrsCount);
          break;
      case CKK_EC0x00000003UL:
      case CKK_EC_EDWARDS0x00000040UL:
      case CKK_EC_MONTGOMERY0x00000041UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, ecPubKeyAttrs,
                                         ecPubKeyAttrsCount);
          break;
      default:
          crv = CKR_DEVICE_ERROR0x00000030UL; /* shouldn't happen unless we store more types
                                   * of token keys into our database. */
  }
1940fail:
  return crv;
1942}
1943CK_RV
1944stfk_CopyTokenSecretKey(SFTKObject *destObject, SFTKTokenObject *src_to)
1945{
  CK_RV crv;
  crv = stfk_CopyTokenAttributes(destObject, src_to, commonKeyAttrs,
                                 commonKeyAttrsCount);
  if (crv != CKR_OK0x00000000UL) {
      goto fail;
  }
  crv = stfk_CopyTokenAttributes(destObject, src_to, secretKeyAttrs,
                                 secretKeyAttrsCount);
1954fail:
  return crv;
1956}

1958/*
* Copy a token object. We need to explicitly copy the relevant
* attributes since token objects don't store those attributes in
* the token itself.
*/
1963CK_RV
1964sftk_CopyTokenObject(SFTKObject *destObject, SFTKObject *srcObject)
1965{
  SFTKTokenObject *src_to = sftk_narrowToTokenObject(srcObject);
  CK_RV crv;

  PORT_Assert(src_to)((src_to) ? ((void)0) : PR_Assert("src_to", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 1969));
  if (src_to == NULL((void*)0)) {
      return CKR_DEVICE_ERROR0x00000030UL; /* internal state inconsistant */
  }

  crv = stfk_CopyTokenAttributes(destObject, src_to, commonAttrs,
                                 commonAttrsCount);
  if (crv != CKR_OK0x00000000UL) {
      goto fail;
  }
  switch (src_to->obj.objclass) {
      case CKO_CERTIFICATE0x00000001UL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, certAttrs,
                                         certAttrsCount);
          break;
      case CKO_NSS_TRUST((0x80000000UL | 0x4E534350) + 3):
          crv = stfk_CopyTokenAttributes(destObject, src_to, nssTrustAttrs,
                                         nssTrustAttrsCount);
          break;
      case CKO_TRUST0x0000000bUL:
          crv = stfk_CopyTokenAttributes(destObject, src_to, trustAttrs,
                                         trustAttrsCount);
          break;
      case CKO_NSS_SMIME((0x80000000UL | 0x4E534350) + 2):
          crv = stfk_CopyTokenAttributes(destObject, src_to, smimeAttrs,
                                         smimeAttrsCount);
          break;
      case CKO_NSS_CRL((0x80000000UL | 0x4E534350) + 1):
          crv = stfk_CopyTokenAttributes(destObject, src_to, crlAttrs,
                                         crlAttrsCount);
          break;
      case CKO_PRIVATE_KEY0x00000003UL:
          crv = stfk_CopyTokenPrivateKey(destObject, src_to);
          break;
      case CKO_PUBLIC_KEY0x00000002UL:
          crv = stfk_CopyTokenPublicKey(destObject, src_to);
          break;
      case CKO_SECRET_KEY0x00000004UL:
          crv = stfk_CopyTokenSecretKey(destObject, src_to);
          break;
      default:
          crv = CKR_DEVICE_ERROR0x00000030UL; /* shouldn't happen unless we store more types
                                   * of token keys into our database. */
  }
2013fail:
  return crv;
2015}

2017/*
* copy the attributes from one object to another. Don't overwrite existing
* attributes. NOTE: This is a pretty expensive operation since it
* grabs the attribute locks for the src object for a *long* time.
*/
2022CK_RV
2023sftk_CopyObject(SFTKObject *destObject, SFTKObject *srcObject)
2024{
  SFTKAttribute *attribute;
  SFTKSessionObject *src_so = sftk_narrowToSessionObject(srcObject);
  SFTKSessionObject *dest_so = sftk_narrowToSessionObject(destObject);
  unsigned int i;

  destObject->validation_value = srcObject->validation_value;
  destObject->source = srcObject->source;
  if (src_so == NULL((void*)0)) {
      return sftk_CopyTokenObject(destObject, srcObject);
  }
  PORT_Assert(dest_so != NULL)((dest_so != ((void*)0)) ? ((void)0) : PR_Assert("dest_so != NULL"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 2035
));
  if (dest_so == NULL((void*)0)) {
      return CKR_ARGUMENTS_BAD0x00000007UL;
  }

  PR_Lock(src_so->attributeLock);
  for (i = 0; i < src_so->hashSize; i++) {
      attribute = src_so->head[i];
      do {
          if (attribute) {
              SFTKAttribute *existing;
              sftkqueue_find(existing, attribute->handle,for ((existing) = (dest_so->head)[((PRUint32)((attribute->
handle) * 1791398085) & (dest_so->hashSize - 1))]; (existing
) != ((void*)0); (existing) = (existing)->next) { if ((existing
)->handle == (attribute->handle)) { break; } }
                             dest_so->head, dest_so->hashSize)for ((existing) = (dest_so->head)[((PRUint32)((attribute->
handle) * 1791398085) & (dest_so->hashSize - 1))]; (existing
) != ((void*)0); (existing) = (existing)->next) { if ((existing
)->handle == (attribute->handle)) { break; } };
              if (!existing) {
                  /* we need to copy the attribute since each attribute
                   * only has one set of link list pointers */
                  SFTKAttribute *newAttribute = sftk_InitAttribute(
                      dest_so, dest_so->nextAttr++,
                      sftk_attr_expand(&attribute->attrib)(&attribute->attrib)->type, (&attribute->attrib
)->pValue, (&attribute->attrib)->ulValueLen);
                  if (newAttribute == NULL((void*)0)) {
                      PR_Unlock(src_so->attributeLock);
                      return CKR_HOST_MEMORY0x00000002UL;
                  }
                  sftkqueue_add(newAttribute, newAttribute->handle,{ int tmp = ((PRUint32)((newAttribute->handle) * 1791398085
) & (dest_so->hashSize - 1)); (newAttribute)->next =
 (dest_so->head)[tmp]; (newAttribute)->prev = ((void*)0
); if ((dest_so->head)[tmp]) (dest_so->head)[tmp]->prev
 = (newAttribute); (dest_so->head)[tmp] = (newAttribute); }
                                dest_so->head, dest_so->hashSize){ int tmp = ((PRUint32)((newAttribute->handle) * 1791398085
) & (dest_so->hashSize - 1)); (newAttribute)->next =
 (dest_so->head)[tmp]; (newAttribute)->prev = ((void*)0
); if ((dest_so->head)[tmp]) (dest_so->head)[tmp]->prev
 = (newAttribute); (dest_so->head)[tmp] = (newAttribute); };
              }
              attribute = attribute->next;
          }
      } while (attribute != NULL((void*)0));
  }
  PR_Unlock(src_so->attributeLock);

  return CKR_OK0x00000000UL;
2068}

2070/*
* ******************** Search Utilities *******************************
*/

2074/* add an object to a search list */
2075CK_RV
2076AddToList(SFTKObjectListElement **list, SFTKObject *object)
2077{
  SFTKObjectListElement *newElem =
      (SFTKObjectListElement *)PORT_AllocPORT_Alloc_Util(sizeof(SFTKObjectListElement));

  if (newElem == NULL((void*)0))
      return CKR_HOST_MEMORY0x00000002UL;

  newElem->next = *list;
  newElem->object = object;
  sftk_ReferenceObject(object);

  *list = newElem;
  return CKR_OK0x00000000UL;
2090}

2092/* return true if the object matches the template */
2093PRBool
2094sftk_objectMatch(SFTKObject *object, CK_ATTRIBUTE_PTR theTemplate, int count)
2095{
  int i;

  for (i = 0; i < count; i++) {
6
←
Assuming 'i' is < 'count'→
7
←
Loop condition is true.  Entering loop body→
      SFTKAttribute *attribute = sftk_FindAttribute(object, theTemplate[i].type);
8
←
Calling 'sftk_FindAttribute'→
25
←
Returning from 'sftk_FindAttribute'→
      if (attribute25.1
'attribute' is not equal to NULL
 == NULL((void*)0)) {
26
←
Taking false branch→
          return PR_FALSE0;
      }
      if (attribute->attrib.ulValueLen == theTemplate[i].ulValueLen) {
27
←
Assuming 'attribute->attrib.ulValueLen' is equal to 'theTemplate[i].ulValueLen'→
28
←
Taking true branch→
          if (PORT_Memcmpmemcmp(attribute->attrib.pValue, theTemplate[i].pValue,
29
←
Null pointer passed to 1st parameter expecting 'nonnull'
                          theTemplate[i].ulValueLen) == 0) {
              sftk_FreeAttribute(attribute);
              continue;
          }
      }
      sftk_FreeAttribute(attribute);
      return PR_FALSE0;
  }
  return PR_TRUE1;
2114}

2116/* search through all the objects in the queue and return the template matches
* in the object list.
*/
2119CK_RV
2120sftk_searchObjectList(SFTKSearchResults *search, SFTKObject **head,
                    unsigned int size, PRLock *lock, CK_ATTRIBUTE_PTR theTemplate,
                    int count, PRBool isLoggedIn)
2123{
  unsigned int i;
  SFTKObject *object;
  CK_RV crv = CKR_OK0x00000000UL;

  PR_Lock(lock);
  for (i = 0; i < size; i++) {
1
Assuming 'i' is < 'size'→
2
←
Loop condition is true.  Entering loop body→
      for (object = head[i]; object != NULL((void*)0); object = object->next) {
3
←
Assuming 'object' is not equal to NULL→
4
←
Loop condition is true.  Entering loop body→
          if (sftk_objectMatch(object, theTemplate, count)) {
5
←
Calling 'sftk_objectMatch'→
              /* don't return objects that aren't yet visible */
              if ((!isLoggedIn) && sftk_isTrue(object, CKA_PRIVATE0x00000002UL))
                  continue;
              sftk_addHandle(search, object->handle);
          }
      }
  }
  PR_Unlock(lock);
  return crv;
2141}

2143/*
* free a single list element. Return the Next object in the list.
*/
2146SFTKObjectListElement *
2147sftk_FreeObjectListElement(SFTKObjectListElement *objectList)
2148{
  SFTKObjectListElement *ol = objectList->next;

  sftk_FreeObject(objectList->object);
  PORT_FreePORT_Free_Util(objectList);
  return ol;
2154}

2156/* free an entire object list */
2157void
2158sftk_FreeObjectList(SFTKObjectListElement *objectList)
2159{
  SFTKObjectListElement *ol;

  for (ol = objectList; ol != NULL((void*)0); ol = sftk_FreeObjectListElement(ol)) {
  }
2164}

2166/*
* free a search structure
*/
2169void
2170sftk_FreeSearch(SFTKSearchResults *search)
2171{
  if (search->handles) {
      PORT_FreePORT_Free_Util(search->handles);
  }
  PORT_FreePORT_Free_Util(search);
2176}

2178/*
* ******************** Session Utilities *******************************
*/

2182/* update the sessions state based in it's flags and wether or not it's
* logged in */
2184void
2185sftk_update_state(SFTKSlot *slot, SFTKSession *session)
2186{
  PR_Lock(slot->slotLock);
  if (slot->isLoggedIn) {
      if (slot->ssoLoggedIn) {
          session->info.state = CKS_RW_SO_FUNCTIONS4;
      } else if (session->info.flags & CKF_RW_SESSION0x00000002UL) {
          session->info.state = CKS_RW_USER_FUNCTIONS3;
      } else {
          session->info.state = CKS_RO_USER_FUNCTIONS1;
      }
  } else {
      if (session->info.flags & CKF_RW_SESSION0x00000002UL) {
          session->info.state = CKS_RW_PUBLIC_SESSION2;
      } else {
          session->info.state = CKS_RO_PUBLIC_SESSION0;
      }
  }
  PR_Unlock(slot->slotLock);
2204}

2206/* update the state of all the sessions on a slot */
2207void
2208sftk_update_all_states(SFTKSlot *slot)
2209{
  unsigned int i;
  SFTKSession *session;

  for (i = 0; i < slot->sessHashSize; i++) {
      PRLock *lock = SFTK_HEAD_BUCKET_LOCK(slot, i)((slot)->sessionLock[((i) >> 0) & (slot)->sessionLockMask
]);
      PR_Lock(lock);
      for (session = slot->head[i]; session; session = session->next) {
          sftk_update_state(slot, session);
      }
      PR_Unlock(lock);
  }
2221}

2223/*
* context are cipher and digest contexts that are associated with a session
*/
2226void
2227sftk_FreeContext(SFTKSessionContext *context)
2228{
  if (context->cipherInfo) {
      (*context->destroy)(context->cipherInfo, PR_TRUE1);
  }
  if (context->hashInfo) {
      (*context->hashdestroy)(context->hashInfo, PR_TRUE1);
  }
  if (context->key) {
      sftk_FreeObject(context->key);
      context->key = NULL((void*)0);
  }
  if (context->signature) {
      SECITEM_FreeItemSECITEM_FreeItem_Util(context->signature, PR_TRUE1);
      context->signature = NULL((void*)0);
  }
  PORT_FreePORT_Free_Util(context);
2244}

2246/*
* Init a new session. NOTE: The session handle is not set, and the
* session is not added to the slot's session queue.
*/
2250CK_RV
2251sftk_InitSession(SFTKSession *session, SFTKSlot *slot, CK_SLOT_ID slotID,
               CK_NOTIFY notify, CK_VOID_PTR pApplication, CK_FLAGS flags)
2253{
  session->next = session->prev = NULL((void*)0);
  session->refCount = 1;
  session->enc_context = NULL((void*)0);
  session->hash_context = NULL((void*)0);
  session->search = NULL((void*)0);
  session->objectIDCount = 1;
  /* session->objects[] is protected by slot->objectLock, not by a
   * per-session lock -- see the lock notes on SFTKSlotStr. */
  session->objects[0] = NULL((void*)0);

  session->slot = slot;
  session->notify = notify;
  session->appData = pApplication;
  session->info.flags = flags;
  session->info.slotID = slotID;
  session->info.ulDeviceError = 0;
  sftk_update_state(slot, session);
  /* no ops completed yet, so the last one couldn't be a FIPS op */
  session->lastOpWasFIPS = PR_FALSE0;
  return CKR_OK0x00000000UL;
2274}

2276/*
* Create a new session and init it.
*/
2279SFTKSession *
2280sftk_NewSession(CK_SLOT_ID slotID, CK_NOTIFY notify, CK_VOID_PTR pApplication,
              CK_FLAGS flags)
2282{
  SFTKSession *session;
  SFTKSlot *slot = sftk_SlotFromID(slotID, PR_FALSE0);
  CK_RV crv;

  if (slot == NULL((void*)0))
      return NULL((void*)0);

  session = (SFTKSession *)PORT_AllocPORT_Alloc_Util(sizeof(SFTKSession));
  if (session == NULL((void*)0))
      return NULL((void*)0);

  crv = sftk_InitSession(session, slot, slotID, notify, pApplication, flags);
  if (crv != CKR_OK0x00000000UL) {
      PORT_FreePORT_Free_Util(session);
      return NULL((void*)0);
  }
  return session;
2300}

2302/* free all the data associated with a session. */
2303void
2304sftk_ClearSession(SFTKSession *session)
2305{
  SFTKSlot *slot = sftk_SlotFromSession(session)((session)->slot);
  SFTKObjectList *op, *next;
  SFTKObjectList *toFree = NULL((void*)0);

  /* Detach every object this session still owns.
   *
   * No one references the session any more, but that does not make it safe
   * to walk this chain unlocked: object handles are slot-global, so a
   * C_DestroyObject on any other session may be removing one of these
   * objects right now. slot->objectLock arbitrates both queues and belongs
   * to the slot, which outlives every session on it.
   */
  PR_Lock(slot->objectLock);
  for (op = session->objects[0]; op != NULL((void*)0); op = next) {
      next = op->next;
      /* Unlink by hand: we are discarding the whole list, so there is no
       * point patching neighbours. */
      op->next = op->prev = NULL((void*)0);
      /* Everything on this list is still in the slot hash -- a claimant
       * unlinks it from both under this lock -- so the claim normally
       * succeeds. The test guards against a path that ever removes an
       * object from only one queue. */
      if (sftk_ClaimObjectRemovalLocked(slot, op->parent)) {
          /* We own the queues' reference, so the object stays alive until
           * we drop it; chain the unlinked element up and free below. */
          op->next = toFree;
          toFree = op;
      }
  }
  session->objects[0] = NULL((void*)0);
  PR_Unlock(slot->objectLock);

  /* An object that outlives us -- because another thread still holds a
   * reference -- keeps a stale so->session pointing here. That is safe:
   * so->session is only dereferenced under slot->objectLock by a thread
   * that has just won the removal claim, and the claim can no longer
   * succeed for an object we have already pulled out of the slot hash. */
  for (op = toFree; op != NULL((void*)0); op = next) {
      next = op->next;
      op->next = NULL((void*)0);
      sftk_FreeObject(op->parent); /* drop the queues' reference */
  }

  if (session->enc_context) {
      sftk_FreeContext(session->enc_context);
      session->enc_context = NULL((void*)0);
  }
  if (session->hash_context) {
      sftk_FreeContext(session->hash_context);
      session->hash_context = NULL((void*)0);
  }
  if (session->search) {
      sftk_FreeSearch(session->search);
      session->search = NULL((void*)0);
  }
2361}

2363/* free the data associated with the session, and the session.
* Caller must have driven refCount to 0; reachable only via sftk_FreeSession. */
2365static void
2366sftk_DestroySession(SFTKSession *session)
2367{
  PORT_ReleaseAssert(session->refCount == 0)((session->refCount == 0) ? ((void)0) : PR_Assert("session->refCount == 0"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 2368
));
  sftk_ClearSession(session);
  PORT_FreePORT_Free_Util(session);
2371}

2373/*
* look up a session structure from a session handle
* generate a reference to it.
*/
2377SFTKSession *
2378sftk_SessionFromHandle(CK_SESSION_HANDLE handle)
2379{
  SFTKSlot *slot = sftk_SlotFromSessionHandle(handle);
  SFTKSession *session;
  PRLock *lock;

  if (!slot)
      return NULL((void*)0);
  lock = SFTK_SESSION_LOCK(slot, handle)((slot)->sessionLock[((((PRUint32)(((handle)) * 1791398085
) & ((slot)->sessHashSize - 1))) >> 0) & (slot
)->sessionLockMask]);

  PR_Lock(lock);
  sftkqueue_find(session, handle, slot->head, slot->sessHashSize)for ((session) = (slot->head)[((PRUint32)((handle) * 1791398085
) & (slot->sessHashSize - 1))]; (session) != ((void*)0
); (session) = (session)->next) { if ((session)->handle
 == (handle)) { break; } };
  if (session)
      session->refCount++;
  PR_Unlock(lock);

  return (session);
2395}

2397/*
* release a reference to a session. The slot's session bucket holds the
* initial reference (created by sftk_InitSession); sftk_SessionFromHandle
* adds another for the duration of the caller's use. NSC_CloseSession and
* sftk_CloseAllSessions drop the bucket's reference once the session has
* been removed from the queue. The thread that drives refCount to 0
* destroys the session.
*/
2405void
2406sftk_FreeSession(SFTKSession *session)
2407{
  PRBool destroy = PR_FALSE0;
  SFTKSlot *slot = sftk_SlotFromSession(session)((session)->slot);
  PRLock *lock = SFTK_SESSION_LOCK(slot, session->handle)((slot)->sessionLock[((((PRUint32)(((session->handle)) *
 1791398085) & ((slot)->sessHashSize - 1))) >> 0
) & (slot)->sessionLockMask]);

  PR_Lock(lock);
  PORT_ReleaseAssert(session->refCount > 0)((session->refCount > 0) ? ((void)0) : PR_Assert("session->refCount > 0"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 2413
));
  if (session->refCount == 1)
      destroy = PR_TRUE1;
  session->refCount--;
  PR_Unlock(lock);

  if (destroy)
      sftk_DestroySession(session);
2421}

2423void
2424sftk_addHandle(SFTKSearchResults *search, CK_OBJECT_HANDLE handle)
2425{
  if (search->handles == NULL((void*)0)) {
      return;
  }
  if (search->size >= search->array_size) {
      search->array_size += NSC_SEARCH_BLOCK_SIZE5;
      search->handles = (CK_OBJECT_HANDLE *)PORT_ReallocPORT_Realloc_Util(search->handles,
                                                         sizeof(CK_OBJECT_HANDLE) * search->array_size);
      if (search->handles == NULL((void*)0)) {
          return;
      }
  }
  search->handles[search->size] = handle;
  search->size++;
2439}

2441static CK_RV
2442handleToClass(SFTKSlot *slot, CK_OBJECT_HANDLE handle,
            CK_OBJECT_CLASS *objClass)
2444{
  SFTKDBHandle *dbHandle = sftk_getDBForTokenObject(slot, handle);
  CK_ATTRIBUTE objClassTemplate;
  CK_RV crv;

  *objClass = CKO_DATA0x00000000UL;
  objClassTemplate.type = CKA_CLASS0x00000000UL;
  objClassTemplate.pValue = objClass;
  objClassTemplate.ulValueLen = sizeof(*objClass);
  crv = sftkdb_GetAttributeValue(dbHandle, handle, &objClassTemplate, 1);
  sftk_freeDB(dbHandle);
  return crv;
2456}

2458SFTKObject *
2459sftk_NewTokenObject(SFTKSlot *slot, SECItem *dbKey, CK_OBJECT_HANDLE handle)
2460{
  SFTKObject *object = NULL((void*)0);
  PRBool hasLocks = PR_FALSE0;
  CK_RV crv;

  object = sftk_GetObjectFromList(&hasLocks, PR_FALSE0, &tokenObjectList, 0,
                                  PR_FALSE0);
  if (object == NULL((void*)0)) {
      return NULL((void*)0);
  }

  object->handle = handle;
  /* every object must have a class, if we can't get it, the object
   * doesn't exist */
  crv = handleToClass(slot, handle, &object->objclass);
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  object->slot = slot;
  /* set up the validation flags */
  object->validation_value = 0;
  object->validation_attribute.next = NULL((void*)0);
  object->validation_attribute.prev = NULL((void*)0);
  object->validation_attribute.freeAttr = PR_FALSE0;
  object->validation_attribute.freeData = PR_FALSE0;
  object->validation_attribute.handle = CKA_OBJECT_VALIDATION_FLAGS0x0000061eUL;
  object->validation_attribute.attrib.type = CKA_OBJECT_VALIDATION_FLAGS0x0000061eUL;
  object->validation_attribute.attrib.pValue = &object->validation_value;
  object->validation_attribute.attrib.ulValueLen = sizeof(object->validation_value);
  /* initialize the FIPS flag properly */
  sftk_setFIPS(object, sftk_isFIPS(slot->slotID)(((slot->slotID) == 3) || ((slot->slotID) >= 101)));
  object->source = SFTK_SOURCE_DEFAULT;
  object->objectInfo = NULL((void*)0);
  object->infoFree = NULL((void*)0);
  if (!hasLocks) {
      object->refLock = PR_NewLock();
  }
  if (object->refLock == NULL((void*)0)) {
      goto loser;
  }
  object->refCount = 1;
  object->type = SFTK_TOKEN_OBJECT_TYPE0x00000000U;

  return object;
2504loser:
  (void)sftk_DestroyObject(object);
  return NULL((void*)0);
2507}

2509CK_RV
2510sftk_convertSessionToToken(SFTKObject *obj)
2511{
  SECItem *dbKey;
  SFTKSessionObject *so = (SFTKSessionObject *)obj;
  SFTKTokenObject *to = sftk_narrowToTokenObject(obj);
  CK_RV crv;

  sftk_DestroySessionObjectData(so);
  PR_DestroyLock(so->attributeLock);

  sftk_tokenKeyLock(so->obj.slot);
  dbKey = sftk_lookupTokenKeyByHandle(so->obj.slot, so->obj.handle);
  if (dbKey && SECFailure == SECITEM_CopyItemSECITEM_CopyItem_Util(NULL((void*)0), &to->dbKey, dbKey)) {
      crv = CKR_HOST_MEMORY0x00000002UL;
  } else {
      crv = CKR_OK0x00000000UL;
  }
  sftk_tokenKeyUnlock(so->obj.slot);
  return crv;
2529}

2531SFTKSessionObject *
2532sftk_narrowToSessionObject(SFTKObject *obj)
2533{
  PRBool handleSaysSession = !sftk_isToken(obj->handle)(((obj->handle) & 0x80000000L) == 0x80000000L);
  PRBool typeSaysSession = obj->type == SFTK_SESSION_OBJECT_TYPE0xFFFFFFFFU;
  if (handleSaysSession != typeSaysSession) {
      PORT_Assert(0)((0) ? ((void)0) : PR_Assert("0", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 2537));
      return NULL((void*)0);
  }
  return handleSaysSession ? (SFTKSessionObject *)obj : NULL((void*)0);
2541}

2543SFTKTokenObject *
2544sftk_narrowToTokenObject(SFTKObject *obj)
2545{
  PRBool handleSaysToken = sftk_isToken(obj->handle)(((obj->handle) & 0x80000000L) == 0x80000000L);
  PRBool typeSaysToken = obj->type == SFTK_TOKEN_OBJECT_TYPE0x00000000U;
  if (handleSaysToken != typeSaysToken) {
      PORT_Assert(0)((0) ? ((void)0) : PR_Assert("0", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 2549));
      return NULL((void*)0);
  }
  return handleSaysToken ? (SFTKTokenObject *)obj : NULL((void*)0);
2553}

2555/* Constant time helper functions */

2557/* sftk_CKRVToMask returns, in constant time, a mask value of
* all ones if rv == CKR_OK.  Otherwise it returns zero. */
2559unsigned int
2560sftk_CKRVToMask(CK_RV rv)
2561{
  PR_STATIC_ASSERT(CKR_OK == 0)extern void pr_static_assert(int arg[(0x00000000UL == 0) ? 1 :
 -1]);
  return ~PORT_CT_NOT_ZERO(rv)(((PRUint32)((PRInt32)(((rv) | (0 - (rv)))) >> (sizeof(
PRInt32) * 8 - 1))));
2564}

2566/* sftk_CheckCBCPadding checks, in constant time, the padding validity and
* accordingly sets the pad length. */
2568CK_RV
2569sftk_CheckCBCPadding(CK_BYTE_PTR pBuf, unsigned int bufLen,
                   unsigned int blockSize, unsigned int *outPadSize)
2571{
  PORT_Assert(outPadSize)((outPadSize) ? ((void)0) : PR_Assert("outPadSize", "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c"
, 2572));

  /* CBC-padded plaintext is always at least one full block */
  if (bufLen < blockSize || blockSize == 0) {
      *outPadSize = 0;
      return CKR_ENCRYPTED_DATA_INVALID0x00000040UL;
  }

  unsigned int padSize = (unsigned int)pBuf[bufLen - 1];

  /* If padSize <= blockSize, set goodPad to all-1s and all-0s otherwise.*/
  unsigned int goodPad = PORT_CT_DUPLICATE_MSB_TO_ALL(~(blockSize - padSize))((PRUint32)((PRInt32)(~(blockSize - padSize)) >> (sizeof
(PRInt32) * 8 - 1)));
  /* padSize should not be 0 */
  goodPad &= PORT_CT_NOT_ZERO(padSize)(((PRUint32)((PRInt32)(((padSize) | (0 - (padSize)))) >>
 (sizeof(PRInt32) * 8 - 1))));

  unsigned int i;
  for (i = 0; i < blockSize; i++) {
      /* If i < padSize, set loopMask to all-1s and all-0s otherwise.*/
      unsigned int loopMask = PORT_CT_DUPLICATE_MSB_TO_ALL(~(padSize - 1 - i))((PRUint32)((PRInt32)(~(padSize - 1 - i)) >> (sizeof(PRInt32
) * 8 - 1)));
      /* Get the padding value (should be padSize) from buffer */
      unsigned int padVal = pBuf[bufLen - 1 - i];
      /* Update goodPad only if i < padSize */
      goodPad &= PORT_CT_SEL(loopMask, ~(padVal ^ padSize), goodPad)(((loopMask) & (~(padVal ^ padSize))) | (~(loopMask) &
 (goodPad)));
  }

  /* If any of the final padding bytes had the wrong value, one or more
   * of the lower eight bits of |goodPad| will be cleared. We AND the
   * bottom 8 bits together and duplicate the result to all the bits. */
  goodPad &= goodPad >> 4;
  goodPad &= goodPad >> 2;
  goodPad &= goodPad >> 1;
  goodPad <<= sizeof(goodPad) * 8 - 1;
  goodPad = PORT_CT_DUPLICATE_MSB_TO_ALL(goodPad)((PRUint32)((PRInt32)(goodPad) >> (sizeof(PRInt32) * 8 -
 1)));

  /* Set outPadSize to padSize or 0 */
  *outPadSize = PORT_CT_SEL(goodPad, padSize, 0)(((goodPad) & (padSize)) | (~(goodPad) & (0)));
  /* Return OK if the pad is valid */
  return PORT_CT_SEL(goodPad, CKR_OK, CKR_ENCRYPTED_DATA_INVALID)(((goodPad) & (0x00000000UL)) | (~(goodPad) & (0x00000040UL
)));
2610}

2612void
2613sftk_EncodeInteger(PRUint64 integer, CK_ULONG num_bits, CK_BBOOL littleEndian,
                 CK_BYTE_PTR output, CK_ULONG_PTR output_len)
2615{
  if (output_len) {
      *output_len = (num_bits / 8);
  }

  PR_ASSERT(num_bits > 0 && num_bits <= 64 && (num_bits % 8) == 0)((num_bits > 0 && num_bits <= 64 && (num_bits
 % 8) == 0) ? ((void)0) : PR_Assert("num_bits > 0 && num_bits <= 64 && (num_bits % 8) == 0"
, "/root/firefox-clang/security/nss/lib/softoken/pkcs11u.c", 2620
));

  if (littleEndian == CK_TRUE1) {
      for (size_t offset = 0; offset < num_bits / 8; offset++) {
          output[offset] = (unsigned char)((integer >> (offset * 8)) & 0xFF);
      }
  } else {
      for (size_t offset = 0; offset < num_bits / 8; offset++) {
          PRUint64 shift = num_bits - (offset + 1) * 8;
          output[offset] = (unsigned char)((integer >> shift) & 0xFF);
      }
  }
2632}

2634CK_FLAGS
2635sftk_AttributeToFlags(CK_ATTRIBUTE_TYPE op)
2636{
  CK_FLAGS flags = 0;

  switch (op) {
      case CKA_ENCRYPT0x00000104UL:
          flags = CKF_ENCRYPT0x00000100UL;
          break;
      case CKA_DECRYPT0x00000105UL:
          flags = CKF_DECRYPT0x00000200UL;
          break;
      case CKA_WRAP0x00000106UL:
          flags = CKF_WRAP0x00020000UL;
          break;
      case CKA_UNWRAP0x00000107UL:
          flags = CKF_UNWRAP0x00040000UL;
          break;
      case CKA_SIGN0x00000108UL:
          flags = CKF_SIGN0x00000800UL;
          break;
      case CKA_SIGN_RECOVER0x00000109UL:
          flags = CKF_SIGN_RECOVER0x00001000UL;
          break;
      case CKA_VERIFY0x0000010AUL:
          flags = CKF_VERIFY0x00002000;
          break;
      case CKA_VERIFY_RECOVER0x0000010BUL:
          flags = CKF_VERIFY_RECOVER0x00004000UL;
          break;
      case CKA_DERIVE0x0000010CUL:
          flags = CKF_DERIVE0x00080000UL;
          break;
      /* fake attribute to select digesting */
      case CKA_DIGEST0x81000000L:
          flags = CKF_DIGEST0x00000400UL;
          break;
      /* fake attribute to select key gen */
      case CKA_NSS_GENERATE0x81000001L:
          flags = CKF_GENERATE0x00008000UL;
          break;
      /* fake attribute to select key pair gen */
      case CKA_NSS_GENERATE_KEY_PAIR0x81000002L:
          flags = CKF_GENERATE_KEY_PAIR0x00010000UL;
          break;
      /* fake attributes to to handle MESSAGE* flags */
      case CKA_NSS_MESSAGE0x82000000L | CKA_ENCRYPT0x00000104UL:
          flags = CKF_MESSAGE_ENCRYPT0x00000002UL;
          break;
      case CKA_NSS_MESSAGE0x82000000L | CKA_DECRYPT0x00000105UL:
          flags = CKF_MESSAGE_DECRYPT0x00000004UL;
          break;
      case CKA_NSS_MESSAGE0x82000000L | CKA_SIGN0x00000108UL:
          flags = CKF_MESSAGE_SIGN0x00000008UL;
          break;
      case CKA_NSS_MESSAGE0x82000000L | CKA_VERIFY0x0000010AUL:
          flags = CKF_MESSAGE_VERIFY0x00000010UL;
          break;
      default:
          break;
  }
  return flags;
2696}

2698/*
* ******************** Hash Utilities **************************
*/
2701/*
* Utility function for converting PSS/OAEP parameter types into
* HASH_HashTypes. Note: Only SHA family functions are defined in RFC 3447.
*/
2705HASH_HashType
2706sftk_GetHashTypeFromMechanism(CK_MECHANISM_TYPE mech)
2707{
  switch (mech) {
      case CKM_SHA_10x00000220UL:
      case CKG_MGF1_SHA10x00000001UL:
          return HASH_AlgSHA1;
      case CKM_SHA2240x00000255UL:
      case CKG_MGF1_SHA2240x00000005UL:
          return HASH_AlgSHA224;
      case CKM_SHA2560x00000250UL:
      case CKG_MGF1_SHA2560x00000002UL:
          return HASH_AlgSHA256;
      case CKM_SHA3840x00000260UL:
      case CKG_MGF1_SHA3840x00000003UL:
          return HASH_AlgSHA384;
      case CKM_SHA5120x00000270UL:
      case CKG_MGF1_SHA5120x00000004UL:
          return HASH_AlgSHA512;
      default:
          return HASH_AlgNULL;
  }
2727}

2729#ifdef NSS_HAS_FIPS_INDICATORS
2730/**************** FIPS Indicator Utilities *************************/
2731/* sigh, we probably need a version of this in secutil so that both
* softoken and NSS can use it */
2733static SECOidTag
2734sftk_quickGetECCCurveOid(SFTKObject *source)
2735{
  SFTKAttribute *attribute = sftk_FindAttribute(source, CKA_EC_PARAMS0x00000180UL);
  unsigned char *encoded;
  int len;
  SECItem oid;
  SECOidTag tag;

  if (attribute == NULL((void*)0)) {
      return SEC_OID_UNKNOWN;
  }
  encoded = attribute->attrib.pValue;
  len = attribute->attrib.ulValueLen;
  if ((len < 2) || (encoded[0] != SEC_ASN1_OBJECT_ID0x06) ||
      (len != encoded[1] + 2)) {
      sftk_FreeAttribute(attribute);
      return SEC_OID_UNKNOWN;
  }
  oid.data = encoded + 2;
  oid.len = len - 2;
  tag = SECOID_FindOIDTagSECOID_FindOIDTag_Util(&oid);
  sftk_FreeAttribute(attribute);
  return tag;
2757}

2759/* This function currently only returns valid lengths for
* FIPS approved ECC curves. If we want to make this generic
* in the future, that Curve determination can be done in
* the sftk_handleSpecial. Since it's currently only used
* in FIPS indicators, it's currently only compiled with
* the FIPS indicator code */
2765static CK_ULONG
2766sftk_getKeyLength(SFTKObject *source)
2767{
  CK_KEY_TYPE keyType = CKK_INVALID_KEY_TYPE0xffffffffUL;
  CK_ATTRIBUTE_TYPE keyAttribute;
  CK_ULONG keyLength = 0;
  SFTKAttribute *attribute;
  CK_RV crv;

  /* If we don't have a key, then it doesn't have a length.
   * this may be OK (say we are hashing). The mech info will
   * sort this out because algorithms which expect no keys
   * will accept zero length for the keys */
  if (source == NULL((void*)0)) {
      return 0;
  }

  crv = sftk_GetULongAttribute(source, CKA_KEY_TYPE0x00000100UL, &keyType);
  if (crv != CKR_OK0x00000000UL) {
      /* sometimes we're passed a data object, in that case the
       * key length is CKA_VALUE, which is the default */
      keyType = CKK_INVALID_KEY_TYPE0xffffffffUL;
  }
  if ((keyType == CKK_EC0x00000003UL) || (keyType == CKK_EC_EDWARDS0x00000040UL) ||
      (keyType == CKK_EC_MONTGOMERY0x00000041UL)) {
      SECOidTag curve = sftk_quickGetECCCurveOid(source);
      switch (curve) {
          case SEC_OID_CURVE25519:
              /* change when we start algorithm testing on curve25519 */
              return 0;
          case SEC_OID_SECG_EC_SECP256R1SEC_OID_ANSIX962_EC_PRIME256V1:
              return 256;
          case SEC_OID_SECG_EC_SECP384R1:
              return 384;
          case SEC_OID_SECG_EC_SECP521R1:
              /* this is a lie, but it makes the table easier. We don't
               * have to have a double entry for every ECC mechanism */
              return 512;
          default:
              break;
      }
      /* other curves aren't NIST approved, returning 0 will cause these
       * curves to fail FIPS length criteria */
      return 0;
  }

  switch (keyType) {
      case CKK_RSA0x00000000UL:
          keyAttribute = CKA_MODULUS0x00000120UL;
          break;
      case CKK_DSA0x00000001UL:
      case CKK_DH0x00000002UL:
          keyAttribute = CKA_PRIME0x00000130UL;
          break;
      default:
          keyAttribute = CKA_VALUE0x00000011UL;
          break;
  }
  attribute = sftk_FindAttribute(source, keyAttribute);
  if (attribute) {
      keyLength = attribute->attrib.ulValueLen * 8;
      sftk_FreeAttribute(attribute);
  }
  return keyLength;
2829}

2831static PRBool
2832sftk_checkKeyLength(CK_ULONG keyLength, CK_ULONG min,
                  CK_ULONG max, CK_ULONG step)
2834{
  if (keyLength > max) {
      return PR_FALSE0;
  }
  if (keyLength < min) {
      return PR_FALSE0;
  }
  if (step == 0) {
      return PR_TRUE1;
  }
  if (((keyLength - min) % step) != 0) {
      return PR_FALSE0;
  }
  return PR_TRUE1;
2848}

2850PRBool
2851sftk_checkFIPSHash(CK_MECHANISM_TYPE hash, PRBool allowSmall, PRBool allowCMAC)
2852{
  switch (hash) {
      case CKM_AES_CMAC0x0000108AUL:
          return allowCMAC;
      case CKM_SHA_10x00000220UL:
      case CKM_SHA_1_HMAC0x00000221UL:
      case CKM_SHA2240x00000255UL:
      case CKM_SHA224_HMAC0x00000256UL:
          return allowSmall;
      case CKM_SHA2560x00000250UL:
      case CKM_SHA256_HMAC0x00000251UL:
      case CKM_SHA3840x00000260UL:
      case CKM_SHA384_HMAC0x00000261UL:
      case CKM_SHA5120x00000270UL:
      case CKM_SHA512_HMAC0x00000271UL:
          return PR_TRUE1;
  }
  return PR_FALSE0;
2870}

2872/*
* handle specialized FIPS semantics that are too complicated to
* handle with just a table. NOTE: this means any additional semantics
* would have to be coded here before they can be added to the table */
2876static PRBool
2877sftk_handleSpecial(SFTKSlot *slot, CK_MECHANISM *mech,
                 SFTKFIPSAlgorithmList *mechInfo, SFTKObject *source,
                 CK_ULONG keyLength, CK_ULONG targetKeyLength)
2880{
  PRBool allowSmall = PR_FALSE0;
  PRBool allowCMAC = PR_FALSE0;
  switch (mechInfo->special) {
      case SFTKFIPSDH: {
          SECItem dhPrime;
          SECItem dhBase;
          SECItem dhGenerator;
          PRBool fipsOk = PR_FALSE0;
          const SECItem *dhSubPrime;
          CK_RV crv = sftk_Attribute2SecItem(NULL((void*)0), &dhPrime,
                                             source, CKA_PRIME0x00000130UL);
          if (crv != CKR_OK0x00000000UL) {
              return PR_FALSE0;
          }
          crv = sftk_Attribute2SecItem(NULL((void*)0), &dhBase, source, CKA_BASE0x00000132UL);
          if (crv != CKR_OK0x00000000UL) {
              return PR_FALSE0;
          }
          dhSubPrime = sftk_VerifyDH_Prime(&dhPrime, &dhGenerator, PR_TRUE1);
          fipsOk = (dhSubPrime) ? PR_TRUE1 : PR_FALSE0;
          if (fipsOk && (SECITEM_CompareItemSECITEM_CompareItem_Util(&dhBase, &dhGenerator) != 0)) {
              fipsOk = PR_FALSE0;
          }

          SECITEM_ZfreeItemSECITEM_ZfreeItem_Util(&dhPrime, PR_FALSE0);
          SECITEM_ZfreeItemSECITEM_ZfreeItem_Util(&dhBase, PR_FALSE0);
          return fipsOk;
      }
      case SFTKFIPSNone:
          return PR_FALSE0;
      case SFTKFIPSECC:
          /* we've already handled the curve selection in the 'getlength'
           * function */
          return PR_TRUE1;
      case SFTKFIPSAEAD: {
          if (mech->ulParameterLen == 0) {
              /* AEAD ciphers are only in FIPS mode if we are using the
               * MESSAGE interface. This takes an empty parameter
               * in the init function */
              return PR_TRUE1;
          }
          return PR_FALSE0;
      }
      case SFTKFIPSRSAPSS: {
          /* PSS salt must not be longer than the  underlying hash.
           * We verify that the underlying hash of the
           * parameters matches Hash of the combined hash mechanisms, so
           * we don't need to look at the specific PSS mechanism */
          CK_RSA_PKCS_PSS_PARAMS *pss = (CK_RSA_PKCS_PSS_PARAMS *)
                                            mech->pParameter;
          const SECHashObject *hashObj = NULL((void*)0);
          if (mech->ulParameterLen != sizeof(*pss)) {
              return PR_FALSE0;
          }
          /* we use the existing hash utilities to find the length of
           * the hash */
          hashObj = HASH_GetRawHashObject(sftk_GetHashTypeFromMechanism(
              pss->hashAlg));
          if (hashObj == NULL((void*)0)) {
              return PR_FALSE0;
          }
          /* cap the salt for legacy keys */
          if ((keyLength <= 1024) && (pss->sLen > 63)) {
              return PR_FALSE0;
          }
          /* cap the salt based on the hash */
          if (pss->sLen > hashObj->length) {
              return PR_FALSE0;
          }
          return PR_TRUE1;
      }
      case SFTKFIPSPBKDF2: {
          /* from NIST SP 800-132
           * PBKDF2 must have the following addition restrictions
           * (independent of keysize).
           *    1. iteration count must be at least 1000.
           *    2. salt must be at least 128 bits (16 bytes).
           *    3. password must match the length specified in the SP
           */
          CK_PKCS5_PBKD2_PARAMS2 *pbkdf2 = (CK_PKCS5_PBKD2_PARAMS2 *)
                                               mech->pParameter;
          if (mech->ulParameterLen != sizeof(*pbkdf2)) {
              return PR_FALSE0;
          }
          if (pbkdf2 == NULL((void*)0)) {
              return PR_FALSE0;
          }
          if (pbkdf2->iterations < 1000) {
              return PR_FALSE0;
          }
          if (pbkdf2->ulSaltSourceDataLen < 16) {
              return PR_FALSE0;
          }
          if (pbkdf2->ulPasswordLen < SFTKFIPS_PBKDF2_MIN_PW_LEN) {
              return PR_FALSE0;
          }
          return PR_TRUE1;
      }
      /* check the hash mechanisms to make sure they themselves are FIPS */
      case SFTKFIPSChkHashSp800:
          allowCMAC = PR_TRUE1;
          /* fallthrough... will pick up allowSmall as well */
      case SFTKFIPSChkHash:
          allowSmall = PR_TRUE1;
          /* fallthrough */
      case SFTKFIPSChkHashTls:
          if (mech->ulParameterLen < mechInfo->offset + sizeof(CK_ULONG)) {
              return PR_FALSE0;
          }
          return sftk_checkFIPSHash(*(CK_MECHANISM_TYPE *)(((char *)mech->pParameter) + mechInfo->offset),
                                    allowSmall, allowCMAC);
      case SFTKFIPSTlsKeyCheck:
          if (mech->mechanism != CKM_NSS_TLS_KEY_AND_MAC_DERIVE_SHA256((0x80000000UL | 0x4E534350) + 23)) {
              /* unless the mechnism has a built-in hash, check the hash */
              if (mech->ulParameterLen < mechInfo->offset + sizeof(CK_ULONG)) {
                  return PR_FALSE0;
              }
              if (!sftk_checkFIPSHash(*(CK_MECHANISM_TYPE *)(((char *)mech->pParameter) + mechInfo->offset),
                                      PR_FALSE0, PR_FALSE0)) {
                  return PR_FALSE0;
              }
          }
          return sftk_checkKeyLength(targetKeyLength, 112, 512, 1);
      case SFTKFIPSRSAOAEP: {
          CK_RSA_PKCS_OAEP_PARAMS *rsaoaep = (CK_RSA_PKCS_OAEP_PARAMS *)
                                                 mech->pParameter;

          HASH_HashType hash_msg = sftk_GetHashTypeFromMechanism(rsaoaep->hashAlg);
          HASH_HashType hash_pad = sftk_GetHashTypeFromMechanism(rsaoaep->mgf);
          /* message hash and mask generation function must be the same */
          if (hash_pad != hash_msg)
              return PR_FALSE0;

          return sftk_checkFIPSHash(rsaoaep->hashAlg, PR_FALSE0, PR_FALSE0);
      }
      default:
          break;
  }
  /* if we didn't understand the special processing, mark it non-fips */
  return PR_FALSE0;
3021}
3022#endif

3024PRBool
3025sftk_operationIsFIPS(SFTKSlot *slot, CK_MECHANISM *mech, CK_ATTRIBUTE_TYPE op,
                   SFTKObject *source, CK_ULONG targetKeyLength)
3027{
3028#ifndef NSS_HAS_FIPS_INDICATORS
  return PR_FALSE0;
3030#else
  int i;
  CK_FLAGS opFlags;
  CK_ULONG keyLength;

  /* handle all the quick stuff first */
  if (!sftk_isFIPS(slot->slotID)(((slot->slotID) == 3) || ((slot->slotID) >= 101))) {
      return PR_FALSE0;
  }
  if (source && !sftk_hasFIPS(source)) {
      return PR_FALSE0;
  }
  if (mech == NULL((void*)0)) {
      return PR_FALSE0;
  }

  /* now get the calculated values */
  opFlags = sftk_AttributeToFlags(op);
  if (opFlags == 0) {
      return PR_FALSE0;
  }
  keyLength = sftk_getKeyLength(source);

  /* check against our algorithm array */
  for (i = 0; i < SFTK_NUMBER_FIPS_ALGORITHMS; i++) {
      SFTKFIPSAlgorithmList *mechs = &sftk_fips_mechs[i];
      /* if we match the number of records exactly, then we are an
       * approved algorithm in the approved mode with an approved key */
      if ((mech->mechanism == mechs->type) &&
          (opFlags == (mechs->info.flags & opFlags)) &&
          sftk_checkKeyLength(keyLength, mechs->info.ulMinKeySize,
                              mechs->info.ulMaxKeySize, mechs->step) &&
          ((targetKeyLength == 0) || (mechs->special == SFTKFIPSTlsKeyCheck) || sftk_checkKeyLength(targetKeyLength, mechs->info.ulMinKeySize, mechs->info.ulMaxKeySize, mechs->step)) &&
          ((mechs->special == SFTKFIPSNone) ||
           sftk_handleSpecial(slot, mech, mechs, source, keyLength, targetKeyLength))) {
          return PR_TRUE1;
      }
  }
  return PR_FALSE0;
3069#endif
3070}

3072void
3073sftk_setFIPS(SFTKObject *obj, PRBool isFIPS)
3074{
  if (isFIPS) {
      obj->validation_value |= SFTK_VALIDATION_FIPS_FLAG0x00000001L;
  } else {
      obj->validation_value &= ~SFTK_VALIDATION_FIPS_FLAG0x00000001L;
  }
3080}

3082PRBool
3083sftk_hasFIPS(SFTKObject *obj)
3084{
  return (obj->validation_value & SFTK_VALIDATION_FIPS_FLAG0x00000001L) ? PR_TRUE1 : PR_FALSE0;
3086}

3088/*
* create the FIPS Validation objects. If the vendor
* doesn't supply an NSS_FIPS_MODULE_ID, at compile time,
* then we assumethis is an unvalidated module.
*/
3093CK_RV
3094sftk_CreateValidationObjects(SFTKSlot *slot)
3095{
  const char *module_id;
  int module_id_len;
  CK_RV crv = CKR_OK0x00000000UL;
  /* we currently use both vendor specific values and PKCS #11 v3.2
   * values for compatibility for a couple more ESR releases. Then we can
   * drop the vendor specific ones */
  CK_OBJECT_CLASS cko_nss_validation = CKO_NSS_VALIDATION((0x80000000UL | 0x4E534350) + 7);
  CK_OBJECT_CLASS cko_validation = CKO_VALIDATION0x0000000aUL;
  CK_NSS_VALIDATION_TYPE ckv_fips = CKV_NSS_FIPS_140((0x80000000UL | 0x4E534350) + 1);
  CK_FLAGS fipsFlag = SFTK_VALIDATION_FIPS_FLAG0x00000001L;
  CK_VALIDATION_TYPE swValidationType = CKV_TYPE_SOFTWARE0x00000001UL;
  CK_VALIDATION_AUTHORITY_TYPE nistValidationAuthority =
      CKV_AUTHORITY_TYPE_NIST_CMVP0x00000001UL;
  CK_UTF8CHAR us[] = { 'U', 'S' };
  CK_VERSION fips_version = { 3, 0 }; /* FIPS-140-3 */
  CK_ULONG fips_level = 1;            /* or 2 if you validated at level 2 */

3113#ifndef NSS_FIPS_MODULE_ID"Generic NSS " "3.132" " Basic ECC" " Beta" " Unvalidated"
3114#define NSS_FIPS_MODULE_ID"Generic NSS " "3.132" " Basic ECC" " Beta" " Unvalidated" "Generic NSS " SOFTOKEN_VERSION"3.132" " Basic ECC" " Beta" " Unvalidated"
3115#endif
  module_id = NSS_FIPS_MODULE_ID"Generic NSS " "3.132" " Basic ECC" " Beta" " Unvalidated";
  module_id_len = sizeof(NSS_FIPS_MODULE_ID"Generic NSS " "3.132" " Basic ECC" " Beta" " Unvalidated") - 1;
  SFTKObject *object;

  object = sftk_NewObject(slot); /* fill in the handle later */
  if (object == NULL((void*)0)) {
      return CKR_HOST_MEMORY0x00000002UL;
  }
  sftk_setFIPS(object, PR_FALSE0);

  crv = sftk_AddAttributeType(object, CKA_CLASS0x00000000UL, &cko_nss_validation,
                              sizeof(cko_nss_validation));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_NSS_VALIDATION_TYPE((0x80000000UL | 0x4E534350) + 36),
                              &ckv_fips, sizeof(ckv_fips));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_NSS_VALIDATION_VERSION((0x80000000UL | 0x4E534350) + 37),
                              &fips_version, sizeof(fips_version));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_NSS_VALIDATION_LEVEL((0x80000000UL | 0x4E534350) + 38),
                              &fips_level, sizeof(fips_level));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_NSS_VALIDATION_MODULE_ID((0x80000000UL | 0x4E534350) + 39),
                              module_id, module_id_len);
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }

  object->handle = sftk_getNextHandle(slot);
  object->slot = slot;
  sftk_AddObject(&slot->moduleObjects, object);
  sftk_FreeObject(object);

  object = sftk_NewObject(slot); /* fill in the handle later */
  if (object == NULL((void*)0)) {
      return CKR_HOST_MEMORY0x00000002UL;
  }
  sftk_setFIPS(object, PR_FALSE0);
  crv = sftk_AddAttributeType(object, CKA_CLASS0x00000000UL, &cko_validation,
                              sizeof(cko_validation));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_TYPE0x0000061fUL,
                              &swValidationType, sizeof(swValidationType));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_VERSION0x00000620UL,
                              &fips_version, sizeof(fips_version));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_LEVEL0x00000621UL,
                              &fips_level, sizeof(fips_level));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_MODULE_ID0x00000622UL,
                              module_id, module_id_len);
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_FLAG0x00000623UL,
                              &fipsFlag, sizeof(fipsFlag));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_AUTHORITY_TYPE0x00000624UL,
                              &nistValidationAuthority,
                              sizeof(nistValidationAuthority));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_COUNTRY0x00000625UL, us, sizeof(us));
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_CERTIFICATE_IDENTIFIER0x00000626UL,
                              NULL((void*)0), 0);
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_CERTIFICATE_URI0x00000627UL,
                              NULL((void*)0), 0);
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_PROFILE0x00000629UL,
                              NULL((void*)0), 0);
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  crv = sftk_AddAttributeType(object, CKA_VALIDATION_VENDOR_URI0x00000628UL,
                              NULL((void*)0), 0);
  if (crv != CKR_OK0x00000000UL) {
      goto loser;
  }
  /* future, fill in validation certificate information from a supplied
   * pointer to a config file */
  object->handle = sftk_getNextHandle(slot);
  object->slot = slot;
  sftk_AddObject(&slot->moduleObjects, object);
3227loser:
  sftk_FreeObject(object);

  return crv;
3231}