/*
* 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);
}
