自学教程：C++ xmlSecTransformCheckId函数代码示例

static intxmlSecNssDigestCheckId(xmlSecTransformPtr transform) {#ifndef XMLSEC_NO_MD5    if(xmlSecTransformCheckId(transform, xmlSecNssTransformMd5Id)) {        return(1);    }#endif /* XMLSEC_NO_MD5 */#ifndef XMLSEC_NO_SHA1    if(xmlSecTransformCheckId(transform, xmlSecNssTransformSha1Id)) {        return(1);    }#endif /* XMLSEC_NO_SHA1 */#ifndef XMLSEC_NO_SHA256    if(xmlSecTransformCheckId(transform, xmlSecNssTransformSha256Id)) {        return(1);    }#endif /* XMLSEC_NO_SHA256 */#ifndef XMLSEC_NO_SHA384    if(xmlSecTransformCheckId(transform, xmlSecNssTransformSha384Id)) {        return(1);    }#endif /* XMLSEC_NO_SHA384 */#ifndef XMLSEC_NO_SHA512    if(xmlSecTransformCheckId(transform, xmlSecNssTransformSha512Id)) {        return(1);    }#endif /* XMLSEC_NO_SHA512 */    return(0);}

static xmlSecSize  xmlSecNssKWAesGetKeySize(xmlSecTransformPtr transform) {    if(xmlSecTransformCheckId(transform, xmlSecNssTransformKWAes128Id)) {	return(XMLSEC_NSS_AES128_KEY_SIZE);    } else if(xmlSecTransformCheckId(transform, xmlSecNssTransformKWAes192Id)) {	return(XMLSEC_NSS_AES192_KEY_SIZE);    } else if(xmlSecTransformCheckId(transform, xmlSecNssTransformKWAes256Id)) {	return(XMLSEC_NSS_AES256_KEY_SIZE);    }    return(0);}

static intxmlSecMSCryptoKWAesCheckId(xmlSecTransformPtr transform) {    if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformKWAes128Id) ||       xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformKWAes192Id) ||       xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformKWAes256Id)) {       return(1);    }    return(0);}

static int xmlSecMSCngSignatureInitialize(xmlSecTransformPtr transform) {    xmlSecMSCngSignatureCtxPtr ctx;    xmlSecAssert2(xmlSecMSCngSignatureCheckId(transform), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecMSCngSignatureSize), -1);    ctx = xmlSecMSCngSignatureGetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    memset(ctx, 0, sizeof(xmlSecMSCngSignatureCtx));#ifndef XMLSEC_NO_ECDSA#ifndef XMLSEC_NO_SHA256    if(xmlSecTransformCheckId(transform, xmlSecMSCngTransformEcdsaSha256Id)) {        ctx->pszHashAlgId = BCRYPT_SHA256_ALGORITHM;        ctx->keyId = xmlSecMSCngKeyDataEcdsaId;    } else#endif /* XMLSEC_NO_SHA256 */#endif /* XMLSEC_NO_ECDSA */    /* not found */    {        xmlSecInvalidTransfromError(transform)        return(-1);    }    return(0);}

static intxmlSecTransformXPointerNodeRead(xmlSecTransformPtr transform, xmlNodePtr node, xmlSecTransformCtxPtr transformCtx) {    xmlSecPtrListPtr dataList;    xmlSecXPathDataPtr data;    xmlNodePtr cur;    int ret;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformXPointerId), -1);    xmlSecAssert2(node != NULL, -1);    xmlSecAssert2(transformCtx != NULL, -1);    dataList = xmlSecXPathTransformGetDataList(transform);    xmlSecAssert2(xmlSecPtrListCheckId(dataList, xmlSecXPathDataListId), -1);    xmlSecAssert2(xmlSecPtrListGetSize(dataList) == 0, -1);    /* there is only one required node */    cur = xmlSecGetNextElementNode(node->children);    if((cur == NULL) || (!xmlSecCheckNodeName(cur, xmlSecNodeXPointer, xmlSecXPointerNs))) {        xmlSecInvalidNodeError(cur, xmlSecNodeXPointer,                               xmlSecTransformGetName(transform));        return(-1);    }    /* read information from the node */    data = xmlSecXPathDataCreate(xmlSecXPathDataTypeXPointer);    if(data == NULL) {        xmlSecInternalError("xmlSecXPathDataCreate",                            xmlSecTransformGetName(transform));        return(-1);    }    ret = xmlSecXPathDataNodeRead(data, cur);    if(ret < 0) {        xmlSecInternalError("xmlSecXPathDataNodeRead",                            xmlSecTransformGetName(transform));        xmlSecXPathDataDestroy(data);        return(-1);    }    /* append it to the list */    ret = xmlSecPtrListAdd(dataList, data);    if(ret < 0) {        xmlSecInternalError("xmlSecPtrListAdd",                            xmlSecTransformGetName(transform));        xmlSecXPathDataDestroy(data);        return(-1);    }    /* set correct node set type and operation */    data->nodeSetOp     = xmlSecNodeSetIntersection;    data->nodeSetType   = xmlSecNodeSetTree;    /* check that we have nothing else */    cur = xmlSecGetNextElementNode(cur->next);    if(cur != NULL) {        xmlSecUnexpectedNodeError(cur, xmlSecTransformGetName(transform));        return(-1);    }    return(0);}

static intxmlSecOpenSSLRsaOaepSetKey(xmlSecTransformPtr transform, xmlSecKeyPtr key) {    xmlSecOpenSSLRsaOaepCtxPtr ctx;    EVP_PKEY* pKey;    RSA *rsa;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformRsaOaepId), -1);    xmlSecAssert2((transform->operation == xmlSecTransformOperationEncrypt) || (transform->operation == xmlSecTransformOperationDecrypt), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecOpenSSLRsaOaepSize), -1);    xmlSecAssert2(key != NULL, -1);    xmlSecAssert2(xmlSecKeyDataCheckId(xmlSecKeyGetValue(key), xmlSecOpenSSLKeyDataRsaId), -1);    ctx = xmlSecOpenSSLRsaOaepGetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    xmlSecAssert2(ctx->pKey == NULL, -1);    pKey = xmlSecOpenSSLKeyDataRsaGetEvp(xmlSecKeyGetValue(key));    if(pKey == NULL) {        xmlSecInternalError("xmlSecOpenSSLKeyDataRsaGetEvp",                            xmlSecTransformGetName(transform));        return(-1);    }    xmlSecAssert2(EVP_PKEY_base_id(pKey) == EVP_PKEY_RSA, -1);    rsa = EVP_PKEY_get0_RSA(pKey);    xmlSecAssert2(rsa != NULL, -1);    ctx->pKey = xmlSecOpenSSLEvpKeyDup(pKey);    if(ctx->pKey == NULL) {        xmlSecInternalError("xmlSecOpenSSLEvpKeyDup",                            xmlSecTransformGetName(transform));        return(-1);    }    return(0);}

static int  	xmlSecMSCryptoRsaPkcs1SetKey(xmlSecTransformPtr transform, xmlSecKeyPtr key) {    xmlSecMSCryptoRsaPkcs1CtxPtr ctx;        xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformRsaPkcs1Id), -1);    xmlSecAssert2((transform->operation == xmlSecTransformOperationEncrypt) || (transform->operation == xmlSecTransformOperationDecrypt), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecMSCryptoRsaPkcs1Size), -1);    xmlSecAssert2(key != NULL, -1);    xmlSecAssert2(xmlSecKeyDataCheckId(xmlSecKeyGetValue(key), xmlSecMSCryptoKeyDataRsaId), -1);    ctx = xmlSecMSCryptoRsaPkcs1GetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    xmlSecAssert2(ctx->data == NULL, -1);    ctx->data = xmlSecKeyDataDuplicate(xmlSecKeyGetValue(key));    if(ctx->data == NULL) {	xmlSecErr_a_ignorar5(XMLSEC_ERRORS_HERE,		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),		    "xmlSecKeyDataDuplicate",		    XMLSEC_ERRORS_R_XMLSEC_FAILED,		    XMLSEC_ERRORS_NO_MESSAGE);	return(-1);    }    return(0);}

static intxmlSecGCryptKWAesInitialize(xmlSecTransformPtr transform) {    xmlSecGCryptKWAesCtxPtr ctx;    int ret;    xmlSecAssert2(xmlSecGCryptKWAesCheckId(transform), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecGCryptKWAesSize), -1);    ctx = xmlSecGCryptKWAesGetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    if(xmlSecTransformCheckId(transform, xmlSecGCryptTransformKWAes128Id)) {        ctx->cipher             = GCRY_CIPHER_AES128;        ctx->keyExpectedSize    = XMLSEC_KW_AES128_KEY_SIZE;    } else if(xmlSecTransformCheckId(transform, xmlSecGCryptTransformKWAes192Id)) {        ctx->cipher             = GCRY_CIPHER_AES192;        ctx->keyExpectedSize    = XMLSEC_KW_AES192_KEY_SIZE;    } else if(xmlSecTransformCheckId(transform, xmlSecGCryptTransformKWAes256Id)) {        ctx->cipher             = GCRY_CIPHER_AES256;        ctx->keyExpectedSize    = XMLSEC_KW_AES256_KEY_SIZE;    } else {        xmlSecError(XMLSEC_ERRORS_HERE,                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),                    NULL,                    XMLSEC_ERRORS_R_INVALID_TRANSFORM,                    XMLSEC_ERRORS_NO_MESSAGE);        return(-1);    }    ctx->mode           = GCRY_CIPHER_MODE_CBC;    ctx->flags          = GCRY_CIPHER_SECURE; /* we are paranoid */    ctx->blockSize      = gcry_cipher_get_algo_blklen(ctx->cipher);    xmlSecAssert2(ctx->blockSize > 0, -1);    ret = xmlSecBufferInitialize(&(ctx->keyBuffer), 0);    if(ret < 0) {        xmlSecError(XMLSEC_ERRORS_HERE,                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),                    "xmlSecGCryptKWAesGetKey",                    XMLSEC_ERRORS_R_XMLSEC_FAILED,                    XMLSEC_ERRORS_NO_MESSAGE);        return(-1);    }    return(0);}

static intxmlSecOpenSSLRsaOaepNodeRead(xmlSecTransformPtr transform, xmlNodePtr node, xmlSecTransformCtxPtr transformCtx) {    xmlSecOpenSSLRsaOaepCtxPtr ctx;    xmlNodePtr cur;    int ret;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformRsaOaepId), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecOpenSSLRsaOaepSize), -1);    xmlSecAssert2(node != NULL, -1);    xmlSecAssert2(transformCtx != NULL, -1);    ctx = xmlSecOpenSSLRsaOaepGetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    xmlSecAssert2(xmlSecBufferGetSize(&(ctx->oaepParams)) == 0, -1);    cur = xmlSecGetNextElementNode(node->children);    while(cur != NULL) {        if(xmlSecCheckNodeName(cur,  xmlSecNodeRsaOAEPparams, xmlSecEncNs)) {            ret = xmlSecBufferBase64NodeContentRead(&(ctx->oaepParams), cur);            if(ret < 0) {                xmlSecInternalError("xmlSecBufferBase64NodeContentRead",                                    xmlSecTransformGetName(transform));                return(-1);            }        } else if(xmlSecCheckNodeName(cur,  xmlSecNodeDigestMethod, xmlSecDSigNs)) {            xmlChar* algorithm;            /* Algorithm attribute is required */            algorithm = xmlGetProp(cur, xmlSecAttrAlgorithm);            if(algorithm == NULL) {                xmlSecInvalidNodeAttributeError(cur, xmlSecAttrAlgorithm,                                                xmlSecTransformGetName(transform),                                                "empty");                return(-1);            }            /* for now we support only sha1 */            if(xmlStrcmp(algorithm, xmlSecHrefSha1) != 0) {                xmlSecInvalidTransfromError2(transform,                                "digest algorithm=/"%s/" is not supported for rsa/oaep",                                xmlSecErrorsSafeString(algorithm));                xmlFree(algorithm);                return(-1);            }            xmlFree(algorithm);        } else {            /* not found */            xmlSecUnexpectedNodeError(cur, xmlSecTransformGetName(transform));            return(-1);        }        /* next node */        cur = xmlSecGetNextElementNode(cur->next);    }    return(0);}

/** * xmlSecTransformXPointerSetExpr: * @transform:          the pointer to XPointer transform. * @expr:               the XPointer expression. * @nodeSetType:        the type of evaluated XPointer expression. * @hereNode:           the pointer to "here" node. * * Sets the XPointer expression for an XPointer @transform. * * Returns: 0 on success or a negative value if an error occurs. */intxmlSecTransformXPointerSetExpr(xmlSecTransformPtr transform, const xmlChar* expr,                            xmlSecNodeSetType  nodeSetType, xmlNodePtr hereNode) {    xmlSecPtrListPtr dataList;    xmlSecXPathDataPtr data;    int ret;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformXPointerId), -1);    xmlSecAssert2(transform->hereNode == NULL, -1);    xmlSecAssert2(expr != NULL, -1);    xmlSecAssert2(hereNode != NULL, -1);    transform->hereNode = hereNode;    dataList = xmlSecXPathTransformGetDataList(transform);    xmlSecAssert2(xmlSecPtrListCheckId(dataList, xmlSecXPathDataListId), -1);    xmlSecAssert2(xmlSecPtrListGetSize(dataList) == 0, -1);    data = xmlSecXPathDataCreate(xmlSecXPathDataTypeXPointer);    if(data == NULL) {        xmlSecInternalError("xmlSecXPathDataCreate",                            xmlSecTransformGetName(transform));        return(-1);    }    ret = xmlSecXPathDataRegisterNamespaces(data, hereNode);    if(ret < 0) {        xmlSecInternalError("xmlSecXPathDataRegisterNamespaces",                            xmlSecTransformGetName(transform));        xmlSecXPathDataDestroy(data);        return(-1);    }    ret = xmlSecXPathDataSetExpr(data, expr);    if(ret < 0) {        xmlSecInternalError("xmlSecXPathDataSetExpr",                            xmlSecTransformGetName(transform));        xmlSecXPathDataDestroy(data);        return(-1);    }    /* append it to the list */    ret = xmlSecPtrListAdd(dataList, data);    if(ret < 0) {        xmlSecInternalError("xmlSecPtrListAdd",                            xmlSecTransformGetName(transform));        xmlSecXPathDataDestroy(data);        return(-1);    }    /* set correct node set type and operation */    data->nodeSetOp     = xmlSecNodeSetIntersection;    data->nodeSetType   = nodeSetType;    return(0);}

/** * xmlSecTransformBase64SetLineSize: * @transform: 		the pointer to BASE64 encode transform. * @lineSize: 		the new max line size. * * Sets the max line size to @lineSize. */voidxmlSecTransformBase64SetLineSize(xmlSecTransformPtr transform, xmlSecSize lineSize) {    xmlSecBase64CtxPtr ctx;        xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecTransformBase64Id));        ctx = xmlSecBase64GetCtx(transform);    xmlSecAssert(ctx != NULL);        ctx->columns = lineSize;    }

static voidxmlSecTransformMemBufFinalize(xmlSecTransformPtr transform) {    xmlSecBufferPtr buffer;    xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecTransformMemBufId));    buffer = xmlSecTransformMemBufGetBuf(transform);    xmlSecAssert(buffer != NULL);    xmlSecBufferFinalize(xmlSecTransformMemBufGetBuf(transform));}

static voidxmlSecBase64Finalize(xmlSecTransformPtr transform) {    xmlSecBase64CtxPtr ctx;        xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecTransformBase64Id));    ctx = xmlSecBase64GetCtx(transform);    xmlSecAssert(ctx != NULL);        xmlSecBase64CtxFinalize(ctx);}

/** * xmlSecTransformMemBufGetBuffer: * @transform:          the pointer to memory buffer transform. * * Gets the pointer to memory buffer transform buffer. * * Returns: pointer to the transform's #xmlSecBuffer. */xmlSecBufferPtrxmlSecTransformMemBufGetBuffer(xmlSecTransformPtr transform) {    xmlSecBufferPtr buffer;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformMemBufId), NULL);    buffer = xmlSecTransformMemBufGetBuf(transform);    xmlSecAssert2(buffer != NULL, NULL);    return(buffer);}

static voidxmlSecGCryptKWDes3Finalize(xmlSecTransformPtr transform) {    xmlSecGCryptKWDes3CtxPtr ctx;    xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecGCryptTransformKWDes3Id));    xmlSecAssert(xmlSecTransformCheckSize(transform, xmlSecGCryptKWDes3Size));    ctx = xmlSecGCryptKWDes3GetCtx(transform);    xmlSecAssert(ctx != NULL);    xmlSecBufferFinalize(&(ctx->keyBuffer));}

static intxmlSecMSCryptoHmacCheckId(xmlSecTransformPtr transform) {#ifndef XMLSEC_NO_SHA1    if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformHmacSha1Id)) {        return(1);    } else#endif /* XMLSEC_NO_SHA1 */#ifndef XMLSEC_NO_SHA256    if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformHmacSha256Id)) {        return(1);    } else#endif /* XMLSEC_NO_SHA256 */#ifndef XMLSEC_NO_SHA384    if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformHmacSha384Id)) {        return(1);    } else#endif /* XMLSEC_NO_SHA384 */#ifndef XMLSEC_NO_SHA512    if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformHmacSha512Id)) {        return(1);    } else#endif /* XMLSEC_NO_SHA512 */#ifndef XMLSEC_NO_MD5    if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformHmacMd5Id)) {        return(1);    } else#endif /* XMLSEC_NO_MD5 */    /* not found */    {        return(0);    }    return(0);}

static int xmlSecMSCryptoRsaPkcs1Initialize(xmlSecTransformPtr transform) {    xmlSecMSCryptoRsaPkcs1CtxPtr ctx;        xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformRsaPkcs1Id), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecMSCryptoRsaPkcs1Size), -1);    ctx = xmlSecMSCryptoRsaPkcs1GetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);        memset(ctx, 0, sizeof(xmlSecMSCryptoRsaPkcs1Ctx));    return(0);}

static intxmlSecNssKWAesInitialize(xmlSecTransformPtr transform) {    xmlSecNssKWAesCtxPtr ctx;    int ret;    xmlSecAssert2(xmlSecNssKWAesCheckId(transform), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecNssKWAesSize), -1);    ctx = xmlSecNssKWAesGetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    if(xmlSecTransformCheckId(transform, xmlSecNssTransformKWAes128Id)) {        ctx->keyExpectedSize = XMLSEC_KW_AES128_KEY_SIZE;    } else if(xmlSecTransformCheckId(transform, xmlSecNssTransformKWAes192Id)) {        ctx->keyExpectedSize = XMLSEC_KW_AES192_KEY_SIZE;    } else if(xmlSecTransformCheckId(transform, xmlSecNssTransformKWAes256Id)) {        ctx->keyExpectedSize = XMLSEC_KW_AES256_KEY_SIZE;    } else {        xmlSecError(XMLSEC_ERRORS_HERE,                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),                    NULL,                    XMLSEC_ERRORS_R_INVALID_TRANSFORM,                    XMLSEC_ERRORS_NO_MESSAGE);        return(-1);    }    ret = xmlSecBufferInitialize(&(ctx->keyBuffer), 0);    if(ret < 0) {        xmlSecError(XMLSEC_ERRORS_HERE,                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),                    "xmlSecBufferInitialize",                    XMLSEC_ERRORS_R_XMLSEC_FAILED,                    XMLSEC_ERRORS_NO_MESSAGE);        return(-1);    }    return(0);}

static intxmlSecOpenSSLHmacCheckId(xmlSecTransformPtr transform) {#ifndef XMLSEC_NO_SHA1    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformHmacSha1Id)) {        return(1);    } else#endif /* XMLSEC_NO_SHA1 */#ifndef XMLSEC_NO_SHA224    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformHmacSha224Id)) {        return(1);    } else#endif /* XMLSEC_NO_SHA224 */#ifndef XMLSEC_NO_SHA256    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformHmacSha256Id)) {        return(1);    } else#endif /* XMLSEC_NO_SHA256 */#ifndef XMLSEC_NO_SHA384    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformHmacSha384Id)) {        return(1);    } else#endif /* XMLSEC_NO_SHA384 */#ifndef XMLSEC_NO_SHA512    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformHmacSha512Id)) {        return(1);    } else#endif /* XMLSEC_NO_SHA512 */#ifndef XMLSEC_NO_RIPEMD160    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformHmacRipemd160Id)) {        return(1);    } else#endif /* XMLSEC_NO_RIPEMD160 */#ifndef XMLSEC_NO_MD5    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformHmacMd5Id)) {        return(1);    } else#endif /* XMLSEC_NO_MD5 */    /* not found */    {        return(0);    }    /* just in case */    return(0);}

static intxmlSecOpenSSLEvpDigestCheckId(xmlSecTransformPtr transform) {#ifndef XMLSEC_NO_MD5    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformMd5Id)) {	return(1);    } else#endif /* XMLSEC_NO_MD5 */    #ifndef XMLSEC_NO_RIPEMD160    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformRipemd160Id)) {	return(1);    } else#endif /* XMLSEC_NO_RIPEMD160 */    #ifndef XMLSEC_NO_SHA1    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha1Id)) {	return(1);    } else#endif /* XMLSEC_NO_SHA1 */    #ifndef XMLSEC_NO_SHA224    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha224Id)) {	return(1);    } else#endif /* XMLSEC_NO_SHA224 */        #ifndef XMLSEC_NO_SHA256    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha256Id)) {	return(1);    } else#endif /* XMLSEC_NO_SHA256 */    #ifndef XMLSEC_NO_SHA384    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha384Id)) {	return(1);    } else#endif /* XMLSEC_NO_SHA384 */    #ifndef XMLSEC_NO_SHA512    if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha512Id)) {	return(1);    } else#endif /* XMLSEC_NO_SHA512 */        {	return(0);    }        return(0);}

static voidxmlSecOpenSSLRsaPkcs1Finalize(xmlSecTransformPtr transform) {    xmlSecOpenSSLRsaPkcs1CtxPtr ctx;    xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformRsaPkcs1Id));    xmlSecAssert(xmlSecTransformCheckSize(transform, xmlSecOpenSSLRsaPkcs1Size));    ctx = xmlSecOpenSSLRsaPkcs1GetCtx(transform);    xmlSecAssert(ctx != NULL);    if(ctx->pKey != NULL) {        EVP_PKEY_free(ctx->pKey);    }    memset(ctx, 0, sizeof(xmlSecOpenSSLRsaPkcs1Ctx));}

static int xmlSecMSCngSignatureCheckId(xmlSecTransformPtr transform) {#ifndef XMLSEC_NO_ECDSA#ifndef XMLSEC_NO_SHA256    if(xmlSecTransformCheckId(transform, xmlSecMSCngTransformEcdsaSha256Id)) {       return(1);    } else#endif /* XMLSEC_NO_SHA256 */#endif /* XMLSEC_NO_ECDSA */    /* not found */    return(0);}

static voidxmlSecOpenSSLRsaOaepFinalize(xmlSecTransformPtr transform) {    xmlSecOpenSSLRsaOaepCtxPtr ctx;    xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformRsaOaepId));    xmlSecAssert(xmlSecTransformCheckSize(transform, xmlSecOpenSSLRsaOaepSize));    ctx = xmlSecOpenSSLRsaOaepGetCtx(transform);    xmlSecAssert(ctx != NULL);    if(ctx->pKey != NULL) {        EVP_PKEY_free(ctx->pKey);    }    xmlSecBufferFinalize(&(ctx->oaepParams));    memset(ctx, 0, sizeof(xmlSecOpenSSLRsaOaepCtx));}

static voidxmlSecRelationshipFinalize(xmlSecTransformPtr transform) {    xmlSecRelationshipCtxPtr ctx;    xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecTransformRelationshipId));    xmlSecAssert(xmlSecTransformCheckSize(transform, xmlSecRelationshipSize));    ctx = xmlSecRelationshipGetCtx(transform);    xmlSecAssert(ctx != NULL);    if(ctx->sourceIdList != NULL) {       xmlSecPtrListDestroy(ctx->sourceIdList);    }    memset(ctx, 0, sizeof(xmlSecRelationshipCtx));}

static intxmlSecRelationshipReadNode(xmlSecTransformPtr transform, xmlNodePtr node, xmlSecTransformCtxPtr transformCtx) {    xmlSecRelationshipCtxPtr ctx;    xmlNodePtr cur;    int ret;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformRelationshipId), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecRelationshipSize), -1);    xmlSecAssert2(node != NULL, -1);    xmlSecAssert2(transformCtx != NULL, -1);    ctx = xmlSecRelationshipGetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    cur = node->children;    while(cur != NULL) {        if(xmlSecCheckNodeName(cur, xmlSecNodeRelationshipReference, xmlSecRelationshipReferenceNs)) {            xmlChar* sourceId;            sourceId = xmlGetProp(cur, xmlSecRelationshipAttrSourceId);            if(sourceId == NULL) {                xmlSecError(XMLSEC_ERRORS_HERE,                            "xmlGetProp",                            xmlSecErrorsSafeString(xmlSecRelationshipAttrSourceId),                            XMLSEC_ERRORS_R_INVALID_NODE_ATTRIBUTE,                            "node=%s",                            xmlSecErrorsSafeString(xmlSecNodeGetName(node)));                return(-1);            }            ret = xmlSecPtrListAdd(ctx->sourceIdList, sourceId);            if(ret < 0) {                xmlSecError(XMLSEC_ERRORS_HERE,                            xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),                            "xmlSecPtrListAdd",                            XMLSEC_ERRORS_R_XMLSEC_FAILED,                            XMLSEC_ERRORS_NO_MESSAGE);                xmlFree(sourceId);                return(-1);            }        }        cur = cur->next;    }    return(0);}

static void xmlSecMSCryptoRsaPkcs1Finalize(xmlSecTransformPtr transform) {    xmlSecMSCryptoRsaPkcs1CtxPtr ctx;    xmlSecAssert(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformRsaPkcs1Id));    xmlSecAssert(xmlSecTransformCheckSize(transform, xmlSecMSCryptoRsaPkcs1Size));    ctx = xmlSecMSCryptoRsaPkcs1GetCtx(transform);    xmlSecAssert(ctx != NULL);        if (ctx->data != NULL)  {	xmlSecKeyDataDestroy(ctx->data);	ctx->data = NULL;    }    memset(ctx, 0, sizeof(xmlSecMSCryptoRsaPkcs1Ctx));}

static intxmlSecOpenSSLRsaOaepExecute(xmlSecTransformPtr transform, int last, xmlSecTransformCtxPtr transformCtx) {    xmlSecOpenSSLRsaOaepCtxPtr ctx;    int ret;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformRsaOaepId), -1);    xmlSecAssert2((transform->operation == xmlSecTransformOperationEncrypt) || (transform->operation == xmlSecTransformOperationDecrypt), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecOpenSSLRsaOaepSize), -1);    xmlSecAssert2(transformCtx != NULL, -1);    ctx = xmlSecOpenSSLRsaOaepGetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    xmlSecAssert2(ctx->pKey != NULL, -1);    if(transform->status == xmlSecTransformStatusNone) {        transform->status = xmlSecTransformStatusWorking;    }    if((transform->status == xmlSecTransformStatusWorking) && (last == 0)) {        /* just do nothing */    } else  if((transform->status == xmlSecTransformStatusWorking) && (last != 0)) {        ret = xmlSecOpenSSLRsaOaepProcess(transform, transformCtx);        if(ret < 0) {            xmlSecError(XMLSEC_ERRORS_HERE,                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),                        "xmlSecOpenSSLRsaOaepProcess",                        XMLSEC_ERRORS_R_XMLSEC_FAILED,                        XMLSEC_ERRORS_NO_MESSAGE);            return(-1);        }        transform->status = xmlSecTransformStatusFinished;    } else if(transform->status == xmlSecTransformStatusFinished) {        /* the only way we can get here is if there is no input */        xmlSecAssert2(xmlSecBufferGetSize(&(transform->inBuf)) == 0, -1);    } else {        xmlSecError(XMLSEC_ERRORS_HERE,                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),                    NULL,                    XMLSEC_ERRORS_R_INVALID_STATUS,                    "status=%d", transform->status);        return(-1);    }    return(0);}

/** * xmlSecTransformVisa3DHackSetID: * @transform:          the pointer to Visa3DHack transform. * @id:                 the ID value. * * Sets the ID value for an Visa3DHack @transform. * * Returns: 0 on success or a negative value if an error occurs. */intxmlSecTransformVisa3DHackSetID(xmlSecTransformPtr transform, const xmlChar* id) {    xmlChar** idPtr;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformVisa3DHackId), -1);    xmlSecAssert2(id != NULL, -1);    idPtr = xmlSecVisa3DHackTransformGetIDPtr(transform);    xmlSecAssert2(idPtr != NULL, -1);    xmlSecAssert2((*idPtr) == NULL, -1);    (*idPtr) = xmlStrdup(id);    if((*idPtr) == NULL) {        xmlSecStrdupError(id, xmlSecTransformGetName(transform));        return(-1);    }    return(0);}

static intxmlSecMSCryptoKWDes3SetKey(xmlSecTransformPtr transform, xmlSecKeyPtr key) {    xmlSecMSCryptoKWDes3CtxPtr ctx;    xmlSecBufferPtr buffer;    xmlSecSize keySize;    int ret;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformKWDes3Id), -1);    xmlSecAssert2((transform->operation == xmlSecTransformOperationEncrypt) || (transform->operation == xmlSecTransformOperationDecrypt), -1);    xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecMSCryptoKWDes3Size), -1);    xmlSecAssert2(key != NULL, -1);    xmlSecAssert2(xmlSecKeyDataCheckId(xmlSecKeyGetValue(key), xmlSecMSCryptoKeyDataDesId), -1);    ctx = xmlSecMSCryptoKWDes3GetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    buffer = xmlSecKeyDataBinaryValueGetBuffer(xmlSecKeyGetValue(key));    xmlSecAssert2(buffer != NULL, -1);    keySize = xmlSecBufferGetSize(buffer);    if(keySize < XMLSEC_KW_DES3_KEY_LENGTH) {        xmlSecError(XMLSEC_ERRORS_HERE,                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),                    NULL,                    XMLSEC_ERRORS_R_INVALID_KEY_DATA_SIZE,                    "key length %d is not enough (%d expected)",                    keySize, XMLSEC_KW_DES3_KEY_LENGTH);        return(-1);    }    ret = xmlSecBufferSetData(&(ctx->keyBuffer), xmlSecBufferGetData(buffer), XMLSEC_KW_DES3_KEY_LENGTH);    if(ret < 0) {        xmlSecError(XMLSEC_ERRORS_HERE,                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),                    "xmlSecBufferSetData",                    XMLSEC_ERRORS_R_XMLSEC_FAILED,                    "size=%d", XMLSEC_KW_DES3_KEY_LENGTH);        return(-1);    }    return(0);}

static intxmlSecBase64Initialize(xmlSecTransformPtr transform) {    xmlSecBase64CtxPtr ctx;    int ret;    xmlSecAssert2(xmlSecTransformCheckId(transform, xmlSecTransformBase64Id), -1);    ctx = xmlSecBase64GetCtx(transform);    xmlSecAssert2(ctx != NULL, -1);    transform->operation = xmlSecTransformOperationDecode;    ret = xmlSecBase64CtxInitialize(ctx, 0, xmlSecBase64GetDefaultLineSize());    if(ret < 0) {        xmlSecInternalError("xmlSecBase64CtxInitialize",                            xmlSecTransformGetName(transform));        return(-1);    }    return(0);}