/* * FUNCTION: pkix_pl_CertPolicyQualifier_Hashcode * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) */ static PKIX_Error * pkix_pl_CertPolicyQualifier_Hashcode( PKIX_PL_Object *object, PKIX_UInt32 *pHashcode, void *plContext) { PKIX_PL_CertPolicyQualifier *certPQ = NULL; PKIX_UInt32 cpidHash = 0; PKIX_UInt32 cpqHash = 0; PKIX_ENTER(CERTPOLICYQUALIFIER, "pkix_pl_CertPolicyQualifier_Hashcode"); PKIX_NULLCHECK_TWO(object, pHashcode); PKIX_CHECK(pkix_CheckType (object, PKIX_CERTPOLICYQUALIFIER_TYPE, plContext), PKIX_OBJECTNOTCERTPOLICYQUALIFIER); certPQ = (PKIX_PL_CertPolicyQualifier *)object; PKIX_NULLCHECK_TWO(certPQ->policyQualifierId, certPQ->qualifier); PKIX_HASHCODE(certPQ->policyQualifierId, &cpidHash, plContext, PKIX_ERRORINOIDHASHCODE); PKIX_HASHCODE(certPQ->qualifier, &cpqHash, plContext, PKIX_ERRORINBYTEARRAYHASHCODE); *pHashcode = cpidHash*31 + cpqHash; cleanup: PKIX_RETURN(CERTPOLICYQUALIFIER); }
/* * FUNCTION: pkix_SingleVerifyNode_Hashcode * DESCRIPTION: * * Computes the hashcode of the attributes of the VerifyNode pointed to by * "node", other than its parents and children, and stores the result at * "pHashcode". * * PARAMETERS: * "node" * Address of VerifyNode to be hashcoded; must be non-NULL * "pHashcode" * Address where UInt32 result will be stored; must be non-NULL * "plContext" * Platform-specific context pointer. * THREAD SAFETY: * Conditionally Thread Safe * (see Thread Safety Definitions in Programmer's Guide) * RETURNS: * Returns NULL if function succeeds * Returns a VerifyNode Error if the function fails in a non-fatal way. * Returns a Fatal Error if the function fails in a fatal way */ static PKIX_Error * pkix_SingleVerifyNode_Hashcode( PKIX_VerifyNode *node, PKIX_UInt32 *pHashcode, void *plContext) { PKIX_UInt32 errorHash = 0; PKIX_UInt32 nodeHash = 0; PKIX_ENTER(VERIFYNODE, "pkix_SingleVerifyNode_Hashcode"); PKIX_NULLCHECK_TWO(node, pHashcode); PKIX_HASHCODE (node->verifyCert, &nodeHash, plContext, PKIX_FAILUREHASHINGCERT); PKIX_CHECK(PKIX_PL_Object_Hashcode ((PKIX_PL_Object *)node->error, &errorHash, plContext), PKIX_FAILUREHASHINGERROR); nodeHash = 31*nodeHash + errorHash; *pHashcode = nodeHash; cleanup: PKIX_RETURN(VERIFYNODE); }
/* * FUNCTION: pkix_Logger_Hashcode * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) */ static PKIX_Error * pkix_Logger_Hashcode( PKIX_PL_Object *object, PKIX_UInt32 *pHashcode, void *plContext) { PKIX_Logger *logger = NULL; PKIX_UInt32 hash = 0; PKIX_UInt32 tempHash = 0; PKIX_ENTER(LOGGER, "pkix_Logger_Hashcode"); PKIX_NULLCHECK_TWO(object, pHashcode); PKIX_CHECK(pkix_CheckType(object, PKIX_LOGGER_TYPE, plContext), PKIX_OBJECTNOTLOGGER); logger = (PKIX_Logger *)object; PKIX_HASHCODE(logger->context, &tempHash, plContext, PKIX_OBJECTHASHCODEFAILED); hash = (((((PKIX_UInt32)((char *)logger->callback - (char *)NULL) + tempHash) << 7) + logger->maxLevel) << 7) + (PKIX_UInt32)logger->logComponent; *pHashcode = hash; cleanup: PKIX_RETURN(LOGGER); }
/* * FUNCTION: pkix_TrustAnchor_Hashcode * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) */ static PKIX_Error * pkix_TrustAnchor_Hashcode( PKIX_PL_Object *object, PKIX_UInt32 *pHashcode, void *plContext) { PKIX_TrustAnchor *anchor = NULL; PKIX_PL_Cert *cert = NULL; PKIX_UInt32 hash = 0; PKIX_UInt32 certHash = 0; PKIX_UInt32 nameHash = 0; PKIX_UInt32 pubKeyHash = 0; PKIX_UInt32 ncHash = 0; PKIX_ENTER(TRUSTANCHOR, "pkix_TrustAnchor_Hashcode"); PKIX_NULLCHECK_TWO(object, pHashcode); PKIX_CHECK(pkix_CheckType(object, PKIX_TRUSTANCHOR_TYPE, plContext), PKIX_OBJECTNOTTRUSTANCHOR); anchor = (PKIX_TrustAnchor*)object; cert = anchor->trustedCert; if (cert){ PKIX_CHECK(PKIX_PL_Object_Hashcode ((PKIX_PL_Object *)cert, &certHash, plContext), PKIX_OBJECTHASHCODEFAILED); hash = certHash; } else { PKIX_CHECK(PKIX_PL_Object_Hashcode ((PKIX_PL_Object *)anchor->caName, &nameHash, plContext), PKIX_OBJECTHASHCODEFAILED); PKIX_CHECK(PKIX_PL_Object_Hashcode ((PKIX_PL_Object *)anchor->caPubKey, &pubKeyHash, plContext), PKIX_OBJECTHASHCODEFAILED); PKIX_HASHCODE(anchor->nameConstraints, &ncHash, plContext, PKIX_OBJECTHASHCODEFAILED); hash = 31 * nameHash + pubKeyHash + ncHash; } *pHashcode = hash; cleanup: PKIX_RETURN(TRUSTANCHOR); }
/* * FUNCTION: pkix_pl_CertPolicyMap_Hashcode * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) */ static PKIX_Error * pkix_pl_CertPolicyMap_Hashcode( PKIX_PL_Object *object, PKIX_UInt32 *pHashcode, void *plContext) { PKIX_UInt32 issuerHash = 0; PKIX_UInt32 subjectHash = 0; PKIX_PL_CertPolicyMap *certMap = NULL; PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Hashcode"); PKIX_NULLCHECK_TWO(object, pHashcode); PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYMAP_TYPE, plContext), PKIX_OBJECTNOTCERTPOLICYMAP); certMap = (PKIX_PL_CertPolicyMap *)object; PKIX_HASHCODE (certMap->issuerDomainPolicy, &issuerHash, plContext, PKIX_OBJECTHASHCODEFAILED); PKIX_HASHCODE (certMap->subjectDomainPolicy, &subjectHash, plContext, PKIX_OBJECTHASHCODEFAILED); *pHashcode = issuerHash*31 + subjectHash; cleanup: PKIX_RETURN(CERTPOLICYMAP); }
/* * FUNCTION: pkix_SinglePolicyNode_Hashcode * DESCRIPTION: * * Computes the hashcode of the attributes of the PolicyNode pointed to by * "node", other than its parents and children, and stores the result at * "pHashcode". * * PARAMETERS: * "node" * Address of PolicyNode to be hashcoded; must be non-NULL * "pHashcode" * Address where UInt32 result will be stored; must be non-NULL * "plContext" * Platform-specific context pointer. * THREAD SAFETY: * Conditionally Thread Safe * (see Thread Safety Definitions in Programmer's Guide) * RETURNS: * Returns NULL if function succeeds * Returns a PolicyNode Error if the function fails in a non-fatal way. * Returns a Fatal Error if the function fails in a fatal way */ static PKIX_Error * pkix_SinglePolicyNode_Hashcode( PKIX_PolicyNode *node, PKIX_UInt32 *pHashcode, void *plContext) { PKIX_UInt32 componentHash = 0; PKIX_UInt32 nodeHash = 0; PKIX_ENTER(CERTPOLICYNODE, "pkix_SinglePolicyNode_Hashcode"); PKIX_NULLCHECK_TWO(node, pHashcode); PKIX_NULLCHECK_TWO(node->validPolicy, node->expectedPolicySet); PKIX_HASHCODE (node->qualifierSet, &nodeHash, plContext, PKIX_FAILUREHASHINGLISTQUALIFIERSET); if (PKIX_TRUE == (node->criticality)) { nodeHash = 31*nodeHash + 0xff; } else { nodeHash = 31*nodeHash + 0x00; } PKIX_CHECK(PKIX_PL_Object_Hashcode ((PKIX_PL_Object *)node->validPolicy, &componentHash, plContext), PKIX_FAILUREHASHINGOIDVALIDPOLICY); nodeHash = 31*nodeHash + componentHash; PKIX_CHECK(PKIX_PL_Object_Hashcode ((PKIX_PL_Object *)node->expectedPolicySet, &componentHash, plContext), PKIX_FAILUREHASHINGLISTEXPECTEDPOLICYSET); nodeHash = 31*nodeHash + componentHash; *pHashcode = nodeHash; cleanup: PKIX_RETURN(CERTPOLICYNODE); }
/* * FUNCTION: pkix_PolicyNode_Hashcode * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) */ static PKIX_Error * pkix_PolicyNode_Hashcode( PKIX_PL_Object *object, PKIX_UInt32 *pHashcode, void *plContext) { PKIX_PolicyNode *node = NULL; PKIX_UInt32 childrenHash = 0; PKIX_UInt32 nodeHash = 0; PKIX_ENTER(CERTPOLICYNODE, "pkix_PolicyNode_Hashcode"); PKIX_NULLCHECK_TWO(object, pHashcode); PKIX_CHECK(pkix_CheckType (object, PKIX_CERTPOLICYNODE_TYPE, plContext), PKIX_OBJECTNOTPOLICYNODE); node = (PKIX_PolicyNode *)object; PKIX_CHECK(pkix_SinglePolicyNode_Hashcode (node, &nodeHash, plContext), PKIX_SINGLEPOLICYNODEHASHCODEFAILED); nodeHash = 31*nodeHash + (PKIX_UInt32)(node->parent); PKIX_HASHCODE (node->children, &childrenHash, plContext, PKIX_OBJECTHASHCODEFAILED); nodeHash = 31*nodeHash + childrenHash; *pHashcode = nodeHash; cleanup: PKIX_RETURN(CERTPOLICYNODE); }
/* * FUNCTION: pkix_ProcessingParams_Hashcode * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) */ static PKIX_Error * pkix_ProcessingParams_Hashcode( PKIX_PL_Object *object, PKIX_UInt32 *pHashcode, void *plContext) { PKIX_ProcessingParams *procParams = NULL; PKIX_UInt32 hash = 0; PKIX_UInt32 anchorsHash = 0; PKIX_UInt32 hintCertsHash = 0; PKIX_UInt32 dateHash = 0; PKIX_UInt32 constraintsHash = 0; PKIX_UInt32 initialHash = 0; PKIX_UInt32 rejectedHash = 0; PKIX_UInt32 certChainCheckersHash = 0; PKIX_UInt32 revCheckersHash = 0; PKIX_UInt32 certStoresHash = 0; PKIX_UInt32 resourceLimitsHash = 0; PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Hashcode"); PKIX_NULLCHECK_TWO(object, pHashcode); PKIX_CHECK(pkix_CheckType (object, PKIX_PROCESSINGPARAMS_TYPE, plContext), PKIX_OBJECTNOTPROCESSINGPARAMS); procParams = (PKIX_ProcessingParams*)object; PKIX_HASHCODE(procParams->trustAnchors, &anchorsHash, plContext, PKIX_OBJECTHASHCODEFAILED); PKIX_HASHCODE(procParams->hintCerts, &hintCertsHash, plContext, PKIX_OBJECTHASHCODEFAILED); PKIX_HASHCODE(procParams->date, &dateHash, plContext, PKIX_OBJECTHASHCODEFAILED); PKIX_HASHCODE(procParams->constraints, &constraintsHash, plContext, PKIX_OBJECTHASHCODEFAILED); PKIX_HASHCODE(procParams->initialPolicies, &initialHash, plContext, PKIX_OBJECTHASHCODEFAILED); rejectedHash = procParams->qualifiersRejected; /* There is no Hash function for CertChainCheckers */ PKIX_HASHCODE(procParams->certStores, &certStoresHash, plContext, PKIX_OBJECTHASHCODEFAILED); PKIX_HASHCODE(procParams->resourceLimits, &resourceLimitsHash, plContext, PKIX_OBJECTHASHCODEFAILED); hash = (31 * ((31 * anchorsHash) + hintCertsHash + dateHash)) + constraintsHash + initialHash + rejectedHash; hash += ((((certStoresHash + resourceLimitsHash) << 7) + certChainCheckersHash + revCheckersHash + procParams->isCrlRevocationCheckingEnabled + procParams->isCrlRevocationCheckingEnabledWithNISTPolicy) << 7); *pHashcode = hash; cleanup: PKIX_RETURN(PROCESSINGPARAMS); }