DOMElement * DSIGTransformXPath::createBlankTransform(DOMDocument * parentDoc) {
safeBuffer str;
const XMLCh * prefix;
DOMElement *ret;
DOMDocument *doc = mp_env->getParentDocument();
prefix = mp_env->getDSIGNSPrefix();
// Create the transform node
makeQName(str, prefix, "Transform");
ret = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
ret->setAttributeNS(NULL,DSIGConstants::s_unicodeStrAlgorithm, DSIGConstants::s_unicodeStrURIXPATH);
// Create the XPath element
makeQName(str, prefix, "XPath");
mp_xpathNode = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
mp_exprTextNode = doc->createTextNode(MAKE_UNICODE_STRING(""));
ret->appendChild(mp_xpathNode);
mp_xpathNode->appendChild(mp_exprTextNode);
mp_txfmNode = ret;
return ret;
}
DOMElement * DSIGKeyInfoValue::createBlankRSAKeyValue(const char * modulus,
const char * exponent) {
// Set the strings
m_modulus.sbStrcpyIn(modulus);
m_exponent.sbStrcpyIn(exponent);
// Set our type
m_keyInfoType = KEYINFO_VALUE_RSA;
// Create the DOM Structure
safeBuffer str;
DOMDocument *doc = mp_parentSignature->getParentDocument();
safeBuffer prefix = mp_parentSignature->getDSIGNSPrefix();
makeQName(str, prefix, "KeyValue");
DOMElement *ret = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
mp_valueNode = ret;
makeQName(str, prefix, "RSAKeyValue");
DOMElement * rsa = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
ret->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
ret->appendChild(rsa);
rsa->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
ret->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
// Now create the value children
makeQName(str, prefix, "Modulus");
DOMElement * v = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
mp_modulusTextNode = doc->createTextNode(MAKE_UNICODE_STRING(modulus));
rsa->appendChild(v);
rsa->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
v->appendChild(mp_modulusTextNode);
makeQName(str, prefix, "Exponent");
v = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
mp_exponentTextNode = doc->createTextNode(MAKE_UNICODE_STRING(exponent));
rsa->appendChild(v);
rsa->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
v->appendChild(mp_exponentTextNode);
return ret;
}
void XENCEncryptionMethodImpl::setKeySize(int size) {
// First map the int to an XMLCh string
XMLCh sizeXMLCh[10];
XMLString::binToText((unsigned int) size, sizeXMLCh, 9, 10);
if (mp_keySizeTextNode == NULL) {
// Get some setup values
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getXENCNSPrefix();
makeQName(str, prefix, s_KeySize);
DOMElement *e = doc->createElementNS(DSIGConstants::s_unicodeStrURIXENC, str.rawXMLChBuffer());
mp_encryptionMethodElement->insertBefore(e, mp_encryptionMethodElement->getFirstChild());
mp_env->doPrettyPrint(mp_encryptionMethodElement);
e->appendChild(mp_keySizeTextNode = doc->createTextNode(sizeXMLCh));
}
else {
mp_keySizeTextNode->setNodeValue(sizeXMLCh);
}
}
DOMElement * XKMSStatusImpl::createBlankStatus(StatusValue status) {
// Get some setup values
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getXKMSNSPrefix();
makeQName(str, prefix, XKMSConstants::s_tagStatus);
mp_statusElement = doc->createElementNS(XKMSConstants::s_unicodeStrURIXKMS,
str.rawXMLChBuffer());
mp_env->doPrettyPrint(mp_statusElement);
/* Now add the StatusValue element */
str.sbXMLChIn(XKMSConstants::s_unicodeStrURIXKMS);
str.sbXMLChCat(XKMSConstants::s_tagStatusValueCodes[status]);
mp_statusElement->setAttributeNS(NULL,
XKMSConstants::s_tagStatusValue,
str.rawXMLChBuffer());
mp_statusValueAttr =
mp_statusElement->getAttributeNodeNS(NULL, XKMSConstants::s_tagStatusValue);
m_statusValue = status;
return mp_statusElement;
}
DOMElement * XKMSUseKeyWithImpl::createBlankUseKeyWith(const XMLCh * application,
const XMLCh * identifier) {
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getXKMSNSPrefix();
makeQName(str, prefix, XKMSConstants::s_tagUseKeyWith);
mp_useKeyWithElement = doc->createElementNS(XKMSConstants::s_unicodeStrURIXKMS,
str.rawXMLChBuffer());
// Setup the Application URI
mp_useKeyWithElement->setAttributeNS(NULL,
XKMSConstants::s_tagApplication,
application);
mp_applicationAttr =
mp_useKeyWithElement->getAttributeNodeNS(NULL, XKMSConstants::s_tagApplication);
// Identifier
mp_useKeyWithElement->setAttributeNS(NULL,
XKMSConstants::s_tagIdentifier,
identifier);
mp_identifierAttr =
mp_useKeyWithElement->getAttributeNodeNS(NULL, XKMSConstants::s_tagIdentifier);
return mp_useKeyWithElement;
}
DOMElement * DSIGKeyInfoName::createBlankKeyName(const XMLCh * name, bool isDName) {
// Create the DOM Structure
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getDSIGNSPrefix();
makeQName(str, prefix, "KeyName");
DOMElement *ret = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
mp_keyInfoDOMNode = ret;
// Check whether to encode prior to adding
if (isDName == true) {
// Treat as a distinguished name
mp_decodedDName = XMLString::replicate(name);
XMLCh * encodedName = encodeDName(name);
mp_keyNameTextNode = doc->createTextNode(encodedName);
XSEC_RELEASE_XMLCH(encodedName);
}
else
mp_keyNameTextNode = doc->createTextNode(name);
ret->appendChild(mp_keyNameTextNode);
mp_name = mp_keyNameTextNode->getNodeValue();
return ret;
}
DOMElement * XENCEncryptionMethodImpl::createBlankEncryptedMethod(const XMLCh * algorithm) {
// Get some setup values
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getXENCNSPrefix();
makeQName(str, prefix, s_EncryptionMethod);
mp_encryptionMethodElement = doc->createElementNS(DSIGConstants::s_unicodeStrURIXENC, str.rawXMLChBuffer());
// Set the algorithm attribute
if (algorithm != NULL) {
mp_encryptionMethodElement->setAttributeNS(NULL,
DSIGConstants::s_unicodeStrAlgorithm,
algorithm);
mp_algorithmAttr =
mp_encryptionMethodElement->getAttributeNodeNS(NULL,
DSIGConstants::s_unicodeStrAlgorithm);
}
return mp_encryptionMethodElement;
}
void XENCEncryptionMethodImpl::setMGF(const XMLCh * mgf) {
if (mp_mgfAlgorithmAttr == NULL) {
// Need to create
if (mp_oaepParamsTextNode == NULL && mp_digestAlgorithmAttr == NULL && mp_keySizeTextNode == NULL) {
mp_env->doPrettyPrint(mp_encryptionMethodElement);
}
// Get some setup values
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getXENC11NSPrefix();
makeQName(str, prefix, s_MGF);
DOMElement *e = doc->createElementNS(DSIGConstants::s_unicodeStrURIXENC11, str.rawXMLChBuffer());
mp_encryptionMethodElement->appendChild(e);
mp_env->doPrettyPrint(mp_encryptionMethodElement);
e->setAttributeNS(NULL,
DSIGConstants::s_unicodeStrAlgorithm,
mgf);
// Set namespace
if (prefix[0] == XERCES_CPP_NAMESPACE_QUALIFIER chNull) {
str.sbTranscodeIn("xmlns");
}
else {
str.sbTranscodeIn("xmlns:");
str.sbXMLChCat(prefix);
}
e->setAttributeNS(DSIGConstants::s_unicodeStrURIXMLNS,
str.rawXMLChBuffer(),
DSIGConstants::s_unicodeStrURIXENC11);
// Now retrieve for later use
mp_mgfAlgorithmAttr =
e->getAttributeNodeNS(NULL,
DSIGConstants::s_unicodeStrAlgorithm);
if (mp_mgfAlgorithmAttr == NULL) {
throw XSECException(XSECException::EncryptionMethodError,
"XENCEncryptionMethod::setMGF - Error creating Algorithm Attribute");
}
}
else {
mp_mgfAlgorithmAttr->setNodeValue(mgf);
}
}
DOMElement * DSIGObject::createBlankObject(void) {
safeBuffer str;
const XMLCh * prefix;
DOMDocument *doc = mp_env->getParentDocument();
prefix = mp_env->getDSIGNSPrefix();
// Create the transform node
makeQName(str, prefix, s_Object);
mp_objectNode = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
mp_idAttr = NULL;
mp_mimeTypeAttr = NULL;
mp_encodingAttr = NULL;
return (DOMElement *) mp_objectNode;
}
DOMElement * DSIGTransformEnvelope::createBlankTransform(DOMDocument * parentDoc) {
safeBuffer str;
const XMLCh * prefix;
DOMElement *ret;
DOMDocument *doc = mp_env->getParentDocument();
prefix = mp_env->getDSIGNSPrefix();
// Create the transform node
makeQName(str, prefix, "Transform");
ret = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
ret->setAttributeNS(NULL,DSIGConstants::s_unicodeStrAlgorithm, DSIGConstants::s_unicodeStrURIENVELOPE);
mp_txfmNode = ret;
return ret;
}
DOMElement * XKMSAuthenticationImpl::createBlankAuthentication(const XMLCh * id) {
// Get some setup values
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getXKMSNSPrefix();
makeQName(str, prefix, XKMSConstants::s_tagAuthentication);
mp_authenticationElement = doc->createElementNS(XKMSConstants::s_unicodeStrURIXKMS,
str.rawXMLChBuffer());
mp_env->doPrettyPrint(mp_authenticationElement);
// This isn't used immediately - it is simply held for when we create a signature
mp_keyBindingId = id;
return mp_authenticationElement;
}
DSIGSignature * XKMSAuthenticationImpl::addKeyBindingAuthenticationSignature(
canonicalizationMethod cm,
signatureMethod sm,
hashMethod hm) {
if (mp_keyBindingId == NULL) {
throw XSECException(XSECException::XKMSError,
"XKMSAuthenticationImpl::addKeyBindingAuthenticationSignature - called prior to key infos being added");
}
DSIGSignature * ret = m_prov.newSignature();
DOMElement * elt = ret->createBlankSignature(mp_env->getParentDocument(), cm, sm, hm);
/* Create the enveloping reference */
safeBuffer sb;
sb.sbXMLChIn(DSIGConstants::s_unicodeStrEmpty);
sb.sbXMLChAppendCh(chPound);
sb.sbXMLChCat(mp_keyBindingId);
DSIGReference *ref = ret->createReference(sb.rawXMLChBuffer());
ref->appendCanonicalizationTransform(CANON_C14NE_COM);
/* Embed the signature in the document inside a KeyBindingAuthentication element */
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getXKMSNSPrefix();
makeQName(str, prefix, XKMSConstants::s_tagKeyBindingAuthentication);
DOMElement * t = doc->createElementNS(XKMSConstants::s_unicodeStrURIXKMS,
str.rawXMLChBuffer());
mp_env->doPrettyPrint(t);
t->appendChild(elt);
mp_env->doPrettyPrint(t);
mp_authenticationElement->appendChild(t);
mp_env->doPrettyPrint(mp_authenticationElement);
return ret;
}
void XENCEncryptionMethodImpl::setOAEPparams(const XMLCh * params) {
if (mp_oaepParamsTextNode == NULL) {
// Need to create
if (mp_mgfAlgorithmAttr == NULL && mp_digestAlgorithmAttr == NULL && mp_keySizeTextNode == NULL) {
mp_env->doPrettyPrint(mp_encryptionMethodElement);
}
// Get some setup values
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getXENCNSPrefix();
makeQName(str, prefix, s_OAEPparams);
DOMNode* inspoint = NULL;
DOMElement *e = doc->createElementNS(DSIGConstants::s_unicodeStrURIXENC, str.rawXMLChBuffer());
if (mp_keySizeTextNode != NULL) {
inspoint = mp_keySizeTextNode->getParentNode()->getNextSibling();
}
else {
inspoint = mp_encryptionMethodElement->getFirstChild();
}
mp_encryptionMethodElement->insertBefore(e, inspoint);
mp_env->doPrettyPrint(mp_encryptionMethodElement);
e->appendChild(mp_oaepParamsTextNode = doc->createTextNode(params));
}
else {
mp_oaepParamsTextNode->setNodeValue(params);
}
}
void DSIGReference::createTransformList(void) {
// Creates the transforms list
safeBuffer str;
const XMLCh * prefix;
DOMDocument *doc = mp_env->getParentDocument();
prefix = mp_env->getDSIGNSPrefix();
if (mp_transformsNode == NULL) {
// Need to create a transforms node
makeQName(str, prefix, "Transforms");
mp_transformsNode = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
mp_referenceNode->insertBefore(mp_transformsNode, mp_referenceNode->getFirstChild());
if (mp_env->getPrettyPrintFlag() == true)
mp_referenceNode->insertBefore(doc->createTextNode(DSIGConstants::s_unicodeStrNL), mp_transformsNode);
mp_env->doPrettyPrint(mp_transformsNode);
// Create the list
XSECnew(mp_transformList, DSIGTransformList());
}
}
DOMElement * DSIGKeyInfoValue::createBlankDSAKeyValue(const char * P,
const char * Q,
const char * G,
const char * Y) {
// Set the strings
m_P.sbStrcpyIn(P);
m_Q.sbStrcpyIn(Q);
m_G.sbStrcpyIn(G);
m_Y.sbStrcpyIn(Y);
// Set our type
m_keyInfoType = KEYINFO_VALUE_DSA;
// Create the DOM Structure
safeBuffer str;
DOMDocument *doc = mp_parentSignature->getParentDocument();
safeBuffer prefix = mp_parentSignature->getDSIGNSPrefix();
makeQName(str, prefix, "KeyValue");
DOMElement *ret = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
mp_valueNode = ret;
makeQName(str, prefix, "DSAKeyValue");
DOMElement * dsa = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
ret->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
ret->appendChild(dsa);
dsa->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
ret->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
// Now create the value children
makeQName(str, prefix, "P");
DOMElement * v = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
mp_PTextNode = doc->createTextNode(MAKE_UNICODE_STRING(P));
dsa->appendChild(v);
dsa->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
v->appendChild(mp_PTextNode);
makeQName(str, prefix, "Q");
v = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
mp_PTextNode = doc->createTextNode(MAKE_UNICODE_STRING(Q));
dsa->appendChild(v);
dsa->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
v->appendChild(mp_PTextNode);
makeQName(str, prefix, "G");
v = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
mp_PTextNode = doc->createTextNode(MAKE_UNICODE_STRING(G));
dsa->appendChild(v);
dsa->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
v->appendChild(mp_PTextNode);
makeQName(str, prefix, "Y");
v = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.sbStrToXMLCh());
mp_PTextNode = doc->createTextNode(MAKE_UNICODE_STRING(Y));
dsa->appendChild(v);
dsa->appendChild(doc->createTextNode(DSIGConstants::s_unicodeStrNL));
v->appendChild(mp_PTextNode);
return ret;
}
XENCEncryptedData * XKMSRegisterResultImpl::setRSAKeyPair(const char * passPhrase,
XMLCh * Modulus,
XMLCh * Exponent,
XMLCh * P,
XMLCh * Q,
XMLCh * DP,
XMLCh * DQ,
XMLCh * InverseQ,
XMLCh * D,
encryptionMethod em,
const XMLCh * algorithmURI) {
// Try to set up the key first - if this fails, don't want to have added the
// XML
const XMLCh * uri;
safeBuffer algorithmSB;
if (em != ENCRYPT_NONE) {
if (encryptionMethod2URI(algorithmSB, em) != true) {
throw XSECException(XSECException::XKMSError,
"XKMSRegisterResult::setRSAKeyPair - Unknown encryption method");
}
uri = algorithmSB.sbStrToXMLCh();
}
else
uri = algorithmURI;
// Find if we can get an algorithm for this URI
XSECAlgorithmHandler *handler;
handler =
XSECPlatformUtils::g_algorithmMapper->mapURIToHandler(
uri);
if (handler == NULL) {
throw XSECException(XSECException::XKMSError,
"XKMSRegisterResult::setRSAKeyPair - unable to handle algorithm");
}
unsigned char kbuf[XSEC_MAX_HASH_SIZE];
unsigned int len = CalculateXKMSKEK((unsigned char *) passPhrase, (int) strlen(passPhrase), kbuf, XSEC_MAX_HASH_SIZE);
if (len == 0) {
throw XSECException(XSECException::XKMSError,
"XKMSRegisterResult::setRSAKeyPair - error deriving KEK");
}
XSECCryptoKey * sk = handler->createKeyForURI(
uri,
(XMLByte *) kbuf,
len);
memset(kbuf, 0, XSEC_MAX_HASH_SIZE);
// Get some setup values
safeBuffer str;
DOMDocument *doc = m_msg.mp_env->getParentDocument();
const XMLCh * prefix = m_msg.mp_env->getXKMSNSPrefix();
makeQName(str, prefix, XKMSConstants::s_tagPrivateKey);
// Create a PrivateKey to add this to
DOMElement * pk = doc->createElementNS(XKMSConstants::s_unicodeStrURIXKMS,
str.rawXMLChBuffer());
m_msg.mp_env->doPrettyPrint(pk);
// Add it to the request doc
m_msg.mp_messageAbstractTypeElement->appendChild(pk);
m_msg.mp_env->doPrettyPrint(m_msg.mp_messageAbstractTypeElement);
// Now create the RSA structure
XKMSRSAKeyPairImpl * rsa;
XSECnew(rsa, XKMSRSAKeyPairImpl(m_msg.mp_env));
DOMElement * e =
rsa->createBlankXKMSRSAKeyPairImpl(Modulus, Exponent, P, Q, DP, DQ, InverseQ, D);
// Add it to the PrivateKey
pk->appendChild(e);
m_msg.mp_env->doPrettyPrint(pk);
// Encrypt all of this for future use
XENCCipher * cipher = m_prov.newCipher(m_msg.mp_env->getParentDocument());
cipher->setKey(sk);
cipher->encryptElementContent(pk, ENCRYPT_NONE, uri);
// Now load the encrypted data back in
return cipher->loadEncryptedData(findFirstElementChild(pk));
}
DOMElement *DSIGSignedInfo::createBlankSignedInfo(canonicalizationMethod cm,
signatureMethod sm,
hashMethod hm) {
safeBuffer str;
safeBuffer prefixNS = mp_parentSignature->getDSIGNSPrefix();
makeQName(str, prefixNS, "SignedInfo");
DOMElement *ret = mp_doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG,
str.sbStrToXMLCh());
mp_signedInfoNode = ret;
// Now create the algorithm parts
m_canonicalizationMethod = cm;
m_signatureMethod = sm;
m_hashMethod = hm;
// Canonicalisation
DOMElement *canMeth = mp_doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG,
makeQName(str, prefixNS, "CanonicalizationMethod").sbStrToXMLCh());
mp_signedInfoNode->appendChild(mp_doc->createTextNode(DSIGConstants::s_unicodeStrNL));
mp_signedInfoNode->appendChild(canMeth);
mp_signedInfoNode->appendChild(mp_doc->createTextNode(DSIGConstants::s_unicodeStrNL));
if (!canonicalizationMethod2URI(str, cm)) {
throw XSECException(XSECException::SignatureCreationError,
"Attempt to use undefined Canonicalisation Algorithm in SignedInfo Creation");
}
canMeth->setAttribute(DSIGConstants::s_unicodeStrAlgorithm, str.sbStrToXMLCh());
// Now the SignatureMethod
DOMElement *sigMeth = mp_doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG,
makeQName(str, prefixNS, "SignatureMethod").sbStrToXMLCh());
mp_signedInfoNode->appendChild(sigMeth);
mp_signedInfoNode->appendChild(mp_doc->createTextNode(DSIGConstants::s_unicodeStrNL));
if (!signatureHashMethod2URI(str, sm, hm)) {
throw XSECException(XSECException::SignatureCreationError,
"Attempt to use undefined Signature/Algorithm combination in SignedInfo Creation");
}
sigMeth->setAttribute(DSIGConstants::s_unicodeStrAlgorithm, str.sbStrToXMLCh());
// Create an empty reference list
XSECnew(mp_referenceList, DSIGReferenceList());
return ret;
}
void XKMSStatusImpl::setStatusReason(StatusValue status, StatusReason reason, bool value) {
if (status == StatusUndefined || reason == ReasonUndefined) {
throw XSECException(XSECException::StatusError,
"XKMSStatus::setStatusReason - status or reason undefined");
}
if ((m_statusReasons[status-1][reason-1] != NULL) == value)
return;
/* Delete if necessary */
if (value == false) {
DOMNode * c = m_statusReasons[status-1][reason-1];
mp_statusElement->removeChild(c);
c->release();
m_statusReasons[status-1][reason-1] = NULL;
return;
}
/* Find a previously found element to insert before*/
DOMNode * found = NULL;
m_statusValue = XKMSStatus::StatusUndefined;
StatusValue i;
StatusReason j = XKMSStatus::Signature;
/* Clean out status codes */
for (i = Indeterminate ; i > StatusUndefined && !(i == status && j == reason); i = (StatusValue)(i-1)) {
for (j = XKMSStatus::Signature; j != XKMSStatus::ReasonUndefined && !(i == status && j == reason); j = (XKMSStatus::StatusReason) (j-1)) {
if (m_statusReasons[i-1][j-1] != NULL)
found = m_statusReasons[i-1][j-1];
}
}
/* Now lets create our new element and its text child */
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
// str.sbXMLChIn(XKMSConstants::s_unicodeStrURIXKMS);
const XMLCh * prefix = mp_env->getXKMSNSPrefix();
if (status == Valid) {
makeQName(str, prefix, XKMSConstants::s_tagValidReason);
}
else if (status == Invalid) {
makeQName(str, prefix, XKMSConstants::s_tagInvalidReason);
}
else {
makeQName(str, prefix, XKMSConstants::s_tagIndeterminateReason);
}
DOMElement * e = doc->createElementNS(XKMSConstants::s_unicodeStrURIXKMS,
str.rawXMLChBuffer());
/* Create the text node child */
str.sbXMLChIn(XKMSConstants::s_unicodeStrURIXKMS);
str.sbXMLChCat(XKMSConstants::s_tagStatusReasonCodes[reason]);
e->appendChild(doc->createTextNode(str.rawXMLChBuffer()));
/* Insert at correct place */
if (found == NULL) {
mp_statusElement->appendChild(e);
mp_env->doPrettyPrint(mp_statusElement);
}
else {
mp_statusElement->insertBefore(e, found);
if (mp_env->getPrettyPrintFlag() == true)
mp_statusElement->insertBefore(doc->createTextNode(DSIGConstants::s_unicodeStrNL), found);
}
m_statusReasons[status-1][reason-1] = e;
}
DOMElement *DSIGReference::createBlankReference(const XMLCh * URI,
const XMLCh * hashAlgorithmURI,
const XMLCh * type) {
// Reset this Reference just in case
m_isManifest = false;
mp_preHash = NULL;
mp_manifestList = NULL;
mp_transformsNode = NULL;
mp_transformList = NULL;
XSECmapURIToHashMethod(hashAlgorithmURI, me_hashMethod);
safeBuffer str;
DOMDocument *doc = mp_env->getParentDocument();
const XMLCh * prefix = mp_env->getDSIGNSPrefix();
makeQName(str, prefix, "Reference");
DOMElement *ret = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
mp_referenceNode = ret;
// Set type
if (type != NULL)
ret->setAttributeNS(NULL, MAKE_UNICODE_STRING("Type"), type);
// Set URI
if (URI != NULL) {
ret->setAttributeNS(NULL, s_unicodeStrURI, URI);
mp_URI = ret->getAttributeNS(NULL, s_unicodeStrURI); // Used later on as a pointer
}
else {
// Anonymous reference
mp_URI = NULL;
}
// Create hash and hashValue nodes
makeQName(str, prefix, "DigestMethod");
DOMElement *digestMethod = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
mp_env->doPrettyPrint(ret);
ret->appendChild(digestMethod);
mp_env->doPrettyPrint(ret);
digestMethod->setAttributeNS(NULL, DSIGConstants::s_unicodeStrAlgorithm,
hashAlgorithmURI);
// Retrieve the attribute value for later use
mp_algorithmURI =
digestMethod->getAttributeNS(NULL, DSIGConstants::s_unicodeStrAlgorithm);
// DigestValue
makeQName(str, prefix, "DigestValue");
mp_hashValueNode = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
ret->appendChild(mp_hashValueNode);
mp_env->doPrettyPrint(ret);
mp_hashValueNode->appendChild(doc->createTextNode(MAKE_UNICODE_STRING("Not yet calculated")));
m_loaded = true;
return ret;
}
