void DSIGObject::load(void) {
if (mp_objectNode == NULL ||
mp_objectNode->getNodeType() != DOMNode::ELEMENT_NODE ||
!strEquals(getDSIGLocalName(mp_objectNode), s_Object)) {
throw XSECException(XSECException::ObjectError,
"Expected <Object> Node in DSIGObject::load");
}
mp_idAttr = ((DOMElement *) mp_objectNode)->getAttributeNodeNS(NULL, s_Id);
if (mp_idAttr) {
#if defined (XSEC_XERCES_HAS_SETIDATTRIBUTE)
((DOMElement *) mp_objectNode)->setIdAttributeNS(NULL, s_Id);
#elif defined (XSEC_XERCES_HAS_BOOLSETIDATTRIBUTE)
((DOMElement *) mp_objectNode)->setIdAttributeNS(NULL, s_Id, true);
#endif
}
mp_mimeTypeAttr = ((DOMElement *) mp_objectNode)->getAttributeNodeNS(NULL, s_MimeType);
mp_encodingAttr = ((DOMElement *) mp_objectNode)->getAttributeNodeNS(NULL, s_Encoding);
}
DSIGReferenceList *DSIGReference::loadReferenceListFromXML(const XSECEnv * env, DOMNode *firstReference) {
// Have the first reference element in the document,
// so want to find and load them all
DOMNode *tmpRef = firstReference;
DSIGReferenceList * refList;
DSIGReference * r;
XSECnew(refList, DSIGReferenceList());
Janitor<DSIGReferenceList> j_refList(refList);
while (tmpRef != 0) {
// Must be an element node
if (tmpRef->getNodeType() != DOMNode::ELEMENT_NODE ||
!strEquals(getDSIGLocalName(tmpRef), "Reference")) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <Reference> as child of <SignedInfo>");
}
XSECnew(r, DSIGReference(env, tmpRef));
refList->addReference(r);
// Load the reference before moving on
r->load();
// Find next element Node
tmpRef = tmpRef->getNextSibling();
while (tmpRef != 0 && tmpRef->getNodeType() != DOMNode::ELEMENT_NODE) {
if (tmpRef->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"EntityReference nodes in <Reference> are unsupported.");
}
tmpRef = tmpRef->getNextSibling();
}
}
j_refList.release();
return refList;
}
void DSIGKeyInfoName::load(void) {
// Assuming we have a valid DOM_Node to start with, load the signing key so that it can
// be used later on
if (mp_keyInfoDOMNode == NULL) {
// Attempt to load an empty signature element
throw XSECException(XSECException::LoadEmptyInfoName);
}
if (!strEquals(getDSIGLocalName(mp_keyInfoDOMNode), "KeyName")) {
throw XSECException(XSECException::LoadNonInfoName);
}
// Now find the text node containing the name
DOMNode *tmpElt = mp_keyInfoDOMNode->getFirstChild();
while (tmpElt != 0 && tmpElt->getNodeType() != DOMNode::TEXT_NODE)
tmpElt = tmpElt->getNextSibling();
if (tmpElt != 0) {
mp_keyNameTextNode = tmpElt;
mp_name = tmpElt->getNodeValue();
}
else {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
MAKE_UNICODE_STRING("Expected TEXT node as child to <KeyName> element"));
}
}
void DSIGSignedInfo::load(void) {
if (mp_signedInfoNode == 0) {
// Attempt to load an empty signature element
throw XSECException(XSECException::LoadEmptySignedInfo);
}
if (!strEquals(getDSIGLocalName(mp_signedInfoNode), "SignedInfo")) {
throw XSECException(XSECException::LoadNonSignedInfo);
}
DOMNode * tmpSI = mp_signedInfoNode->getFirstChild();
// Check for CanonicalizationMethod
while (tmpSI != 0 && (tmpSI->getNodeType() != DOMNode::ELEMENT_NODE))
// Skip text and comments
tmpSI = tmpSI->getNextSibling();
if (tmpSI == 0 || !strEquals(getDSIGLocalName(tmpSI), "CanonicalizationMethod")) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <CanonicalizationMethod> as first child of <SignedInfo>");
}
// Determine what the canonicalization method is
DOMNamedNodeMap *tmpAtts = tmpSI->getAttributes();
DOMNode *algorithm = tmpAtts->getNamedItem(DSIGConstants::s_unicodeStrAlgorithm);
if (algorithm == 0) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected Algorithm attribute in <CanonicalizationMethod>");
}
safeBuffer tmpSB;
tmpSB << (*mp_formatter << algorithm->getNodeValue());
if (tmpSB.sbStrcmp(URI_ID_C14N_NOC) == 0) {
m_canonicalizationMethod = CANON_C14N_NOC;
}
else if (tmpSB.sbStrcmp(URI_ID_C14N_COM) == 0) {
m_canonicalizationMethod = CANON_C14N_COM;
}
else
throw XSECException(XSECException::UnknownCanonicalization);
// Now load the SignatureMethod
tmpSI = tmpSI->getNextSibling();
while (tmpSI != 0 && (tmpSI->getNodeType() != DOMNode::ELEMENT_NODE))
// Skip text and comments
tmpSI = tmpSI->getNextSibling();
if (tmpSI == 0 || !strEquals(getDSIGLocalName(tmpSI), "SignatureMethod")) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <SignatureMethod> as child of <SignedInfo>");
}
// Determine the algorithms used to sign this document
tmpAtts = tmpSI->getAttributes();
algorithm = tmpAtts->getNamedItem(DSIGConstants::s_unicodeStrAlgorithm);
if (algorithm == 0) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected Algorithm attribute in <SignatureMethod>");
}
tmpSB << (*mp_formatter << algorithm->getNodeValue());
if (tmpSB.sbStrcmp(URI_ID_DSA_SHA1) == 0) {
m_signatureMethod = SIGNATURE_DSA;
m_hashMethod = HASH_SHA1;
}
else if (tmpSB.sbStrcmp(URI_ID_RSA_SHA1) == 0) {
m_signatureMethod = SIGNATURE_RSA;
m_hashMethod = HASH_SHA1;
}
else if (tmpSB.sbStrcmp(URI_ID_HMAC_SHA1) == 0) {
m_signatureMethod = SIGNATURE_HMAC;
m_hashMethod = HASH_SHA1;
// Check to see if there is a maximum output value
DOMNode *tmpSOV = tmpSI->getFirstChild();
while (tmpSOV != NULL &&
tmpSOV->getNodeType() != DOMNode::ELEMENT_NODE &&
!strEquals(getDSIGLocalName(tmpSOV), "HMACOutputLength"))
tmpSOV = tmpSOV->getNextSibling();
if (tmpSOV != NULL) {
// Have a max output value!
tmpSOV = tmpSOV->getFirstChild();
while (tmpSOV != NULL && tmpSOV->getNodeType() != DOMNode::TEXT_NODE)
tmpSOV = tmpSOV->getNextSibling();
if (tmpSOV != NULL) {
safeBuffer val;
val << (*mp_formatter << tmpSOV->getNodeValue());
m_HMACOutputLength = atoi((char *) val.rawBuffer());
}
}
}
else
throw XSECException(XSECException::UnknownSignatureAlgorithm);
// Now look at references....
tmpSI = tmpSI->getNextSibling();
// Run through the rest of the elements until done
while (tmpSI != 0 && (tmpSI->getNodeType() != DOMNode::ELEMENT_NODE))
// Skip text and comments
tmpSI = tmpSI->getNextSibling();
if (tmpSI != NULL) {
// Have an element node - should be a reference, so let's load the list
mp_referenceList = DSIGReference::loadReferenceListFromXML(mp_parentSignature, tmpSI);
}
}
void XENCEncryptionMethodImpl::load() {
if (mp_encryptionMethodElement == NULL) {
// Attempt to load an empty encryptedType element
throw XSECException(XSECException::EncryptionMethodError,
"XENCEncryptionMethod::load - called on empty DOM");
}
if (!strEquals(getXENCLocalName(mp_encryptionMethodElement), s_EncryptionMethod)) {
// Attempt to load an empty encryptedData element
throw XSECException(XSECException::EncryptionMethodError,
"XENCEncryptionMethod::load - called on non EncryptionMethod node");
}
// Find the type
mp_algorithmAttr =
mp_encryptionMethodElement->getAttributeNodeNS(NULL,
DSIGConstants::s_unicodeStrAlgorithm);
// Check for known children
DOMElement * c = findFirstElementChild(mp_encryptionMethodElement);
while (c != NULL) {
if (strEquals(getDSIGLocalName(c), s_DigestMethod)) {
mp_digestAlgorithmAttr = c->getAttributeNodeNS(NULL,
DSIGConstants::s_unicodeStrAlgorithm);
if (mp_digestAlgorithmAttr == NULL) {
throw XSECException(XSECException::EncryptionMethodError,
"XENCEncryptionMethod::load - Cannot find Algorithm Attribute in DigestMethod element");
}
}
else if (strEquals(getXENC11LocalName(c), s_MGF)) {
mp_mgfAlgorithmAttr = c->getAttributeNodeNS(NULL,
DSIGConstants::s_unicodeStrAlgorithm);
if (mp_mgfAlgorithmAttr == NULL) {
throw XSECException(XSECException::EncryptionMethodError,
"XENCEncryptionMethod::load - Cannot find Algorithm Attribute in xenc11:MGF element");
}
}
else if (strEquals(getXENCLocalName(c), s_OAEPparams)) {
mp_oaepParamsTextNode = NULL;
mp_oaepParamsTextNode = findFirstChildOfType(c, DOMNode::TEXT_NODE);
if (mp_oaepParamsTextNode == NULL) {
throw XSECException(XSECException::EncryptionMethodError,
"XENCEncryptionMethod::load - Cannot find text value of xenc:OAEPparams element");
}
}
else if (strEquals(getXENCLocalName(c), s_KeySize)) {
mp_keySizeTextNode = NULL;
mp_keySizeTextNode = findFirstChildOfType(c, DOMNode::TEXT_NODE);
if (mp_keySizeTextNode == NULL) {
throw XSECException(XSECException::EncryptionMethodError,
"XENCEncryptionMethod::load - Cannot find text value of xenc:KeySize node");
}
}
c = findNextElementChild(c);
}
}
void DSIGReference::load(void) {
// Load reference info from XML
DOMNamedNodeMap *atts = mp_referenceNode->getAttributes();
DOMNode *tmpElt;
const XMLCh * name;
safeBuffer sbName;
if (atts != 0) {
XMLSize_t size = atts->getLength();
for (XMLSize_t i = 0; i < size; ++i) {
name = atts->item(i)->getNodeName();
sbName << (*mp_formatter << atts->item(i)->getNodeName());
if (strEquals(name, s_unicodeStrURI)) {
mp_URI = atts->item(i)->getNodeValue();
}
else if (strEquals(name, "Type")) {
// Check if a manifest, otherwise ignore for now
if (strEquals(atts->item(i)->getNodeValue(), DSIGConstants::s_unicodeStrURIMANIFEST))
m_isManifest = true;
}
else if (strEquals(name, "Id")) {
// For now ignore
}
else if (sbName.sbStrncmp("xmlns", 5) == 0) {
// Ignore name spaces
}
else {
//safeBuffer tmp, error;
//error << (*mp_formatter << name);
//tmp.sbStrcpyIn("Unknown attribute in <Reference> Element : ");
//tmp.sbStrcatIn(error);
throw XSECException(XSECException::UnknownDSIGAttribute,
"Unknown attribute in <Reference> Element");
}
}
}
// Now check for Transforms
tmpElt = mp_referenceNode->getFirstChild();
while (tmpElt != 0 && (tmpElt->getNodeType() != DOMNode::ELEMENT_NODE)) {
if (tmpElt->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"EntityReference nodes in <Reference> are unsupported.");
}
// Skip text and comments
tmpElt = tmpElt->getNextSibling();
}
if (tmpElt == 0) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <Transforms> or <DigestMethod> within <Reference>");
}
if (strEquals(getDSIGLocalName(tmpElt), "Transforms")) {
// Store node for later use
mp_transformsNode = tmpElt;
// Load the transforms
mp_transformList = loadTransforms(tmpElt, mp_formatter, mp_env);
// Find next node
tmpElt = tmpElt->getNextSibling();
while (tmpElt != 0 && (tmpElt->getNodeType() != DOMNode::ELEMENT_NODE)) {
if (tmpElt->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"EntityReference nodes in <Reference> are unsupported.");
}
tmpElt = tmpElt->getNextSibling();
}
} /* if tmpElt node type = transforms */
else {
mp_transformList = NULL;
}
if (tmpElt == NULL || !strEquals(getDSIGLocalName(tmpElt), "DigestMethod")) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <DigestMethod> element");
}
// Determine what the digest method actually is
atts = tmpElt->getAttributes();
unsigned int i;
for (i = 0; i < atts->getLength() &&
!strEquals(atts->item(i)->getNodeName(), DSIGConstants::s_unicodeStrAlgorithm); ++i);
if (i == atts->getLength()) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected 'Algorithm' attribute in <DigestMethod>");
}
mp_algorithmURI = atts->item(i)->getNodeValue();
// Determine hashing algorithm
XSECmapURIToHashMethod(mp_algorithmURI, me_hashMethod);
// Find the hash value node
tmpElt = tmpElt->getNextSibling();
while (tmpElt != 0 &&
(tmpElt->getNodeType() != DOMNode::ELEMENT_NODE || !strEquals(getDSIGLocalName(tmpElt), "DigestValue"))) {
if (tmpElt->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"EntityReference nodes in <Reference> are unsupported.");
}
tmpElt = tmpElt->getNextSibling();
}
if (tmpElt == 0) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <DigestValue> within <Reference>");
}
mp_hashValueNode = tmpElt;
// If we are a manifest, then we need to load the manifest references
if (m_isManifest) {
// Find the manifest node - we cheat and use a transform
TXFMBase * docObject;
DOMNode * manifestNode, * referenceNode;
docObject = getURIBaseTXFM(mp_referenceNode->getOwnerDocument(), mp_URI,
mp_env);
manifestNode = docObject->getFragmentNode();
delete docObject;
// Now search downwards to find a <Manifest>
if (manifestNode == 0 || manifestNode->getNodeType() != DOMNode::ELEMENT_NODE ||
(!strEquals(getDSIGLocalName(manifestNode), "Object") && !strEquals(getDSIGLocalName(manifestNode), "Manifest"))) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <Manifest> or <Object> URI for Manifest Type <Reference>");
}
if (strEquals(getDSIGLocalName(manifestNode), "Object")) {
// Find Manifest child
manifestNode = manifestNode->getFirstChild();
while (manifestNode != 0 && manifestNode->getNodeType() != DOMNode::ELEMENT_NODE) {
if (manifestNode->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"EntityReference nodes in <Reference> are unsupported.");
}
manifestNode = manifestNode->getNextSibling();
}
if (manifestNode == 0 || !strEquals(getDSIGLocalName(manifestNode), "Manifest"))
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <Manifest> as child of <Object> for Manifest Type <Reference>");
}
// Now have the manifest node, find the first reference and load!
referenceNode = manifestNode->getFirstChild();
while (referenceNode != 0 &&
(referenceNode->getNodeType() != DOMNode::ELEMENT_NODE || !strEquals(getDSIGLocalName(referenceNode), "Reference"))) {
if (referenceNode->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"EntityReference nodes in <Reference> are unsupported.");
}
referenceNode = referenceNode->getNextSibling();
}
if (referenceNode == 0)
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <Reference> as child of <Manifest>");
// Have reference node, so lets create a list!
mp_manifestList = DSIGReference::loadReferenceListFromXML(mp_env, referenceNode);
} /* m_isManifest */
m_loaded = true;
}
unsigned int DSIGReference::readHash(XMLByte *toFill, unsigned int maxToFill) {
// Determine the hash value stored in the reference
// First set up for input
unsigned int size;
DOMNode *tmpElt;
//const XMLCh * stringHash;
TXFMBase * nextInput;
DOMDocument *d = mp_referenceNode->getOwnerDocument();
safeBuffer b64HashVal;
// Find the hash value
tmpElt = mp_referenceNode->getFirstChild();
while (tmpElt != 0 && !strEquals(getDSIGLocalName(tmpElt), "DigestValue"))
tmpElt = tmpElt->getNextSibling();
if (tmpElt == NULL)
// ERROR
return 0;
// Now read the DOMString of the hash
tmpElt = tmpElt->getFirstChild();
while (tmpElt != NULL && tmpElt->getNodeType() != DOMNode::TEXT_NODE)
tmpElt = tmpElt->getNextSibling();
if (tmpElt == NULL)
// Something wrong with the underlying XML if no text was found
throw XSECException(XSECException::NoHashFoundInDigestValue);
b64HashVal << (*mp_formatter << tmpElt->getNodeValue());
// Now have the value of the string - create a transform around it
XSECnew(nextInput, TXFMSB(d));
((TXFMSB *) nextInput)->setInput(b64HashVal);
// Create a transform chain (really as a janitor for the entire list)
TXFMChain * chain;
XSECnew(chain, TXFMChain(nextInput));
Janitor<TXFMChain> j_chain(chain);
// Now create the base64 transform
XSECnew(nextInput, TXFMBase64(d));
chain->appendTxfm(nextInput);
// Now get the value
size = chain->getLastTxfm()->readBytes(toFill, maxToFill);
// Clear any documentat modifications
chain->getLastTxfm()->deleteExpandedNameSpaces();
return size;
}
DSIGTransformList * DSIGReference::loadTransforms(
DOMNode *transformsNode,
XSECSafeBufferFormatter * formatter,
const XSECEnv * env) {
// This is defined as a static function, not because it makes use of any static variables
// in the DSIGReference class, but to neatly link it to the other users
if (transformsNode == 0 || (!strEquals(getDSIGLocalName(transformsNode), "Transforms") &&
!strEquals(getXENCLocalName(transformsNode), "Transforms"))) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <Transforms> in function DSIGReference::processTransforms");
}
// Create the list
DSIGTransformList * lst;
XSECnew(lst, DSIGTransformList());
Janitor<DSIGTransformList> j_lst(lst);
// Find First transform
DOMNode * transforms = transformsNode->getFirstChild();
while (transforms != NULL && transforms->getNodeType() != DOMNode::ELEMENT_NODE)
transforms = transforms->getNextSibling();
while (transforms != NULL) {
// Process each transform in turn
if (!strEquals(getDSIGLocalName(transforms), "Transform")) {
// Not what we expected to see!
safeBuffer tmp, error;
error << (*formatter << getDSIGLocalName(transforms));
tmp.sbStrcpyIn("Unknown attribute in <Transforms> - Expected <Transform> found ");
tmp.sbStrcatIn(error);
tmp.sbStrcatIn(">.");
throw XSECException(XSECException::ExpectedDSIGChildNotFound, error.rawCharBuffer());
}
DOMNamedNodeMap * transformAtts = transforms->getAttributes();
unsigned int i;
for (i = 0; i < transformAtts->getLength() &&
!strEquals(transformAtts->item(i)->getNodeName(), DSIGConstants::s_unicodeStrAlgorithm); ++i);
if (i == transformAtts->getLength()) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Algorithm attribute not found in <Transform> element");
}
safeBuffer algorithm;
algorithm << (*formatter << transformAtts->item(i)->getNodeValue());
// Determine what the transform is
if (algorithm.sbStrcmp(URI_ID_BASE64) == 0) {
DSIGTransformBase64 * b;
XSECnew(b, DSIGTransformBase64(env, transforms));
lst->addTransform(b);
b->load();
}
else if (algorithm.sbStrcmp(URI_ID_XPATH) == 0) {
DSIGTransformXPath * x;
XSECnew(x, DSIGTransformXPath(env, transforms));
lst->addTransform(x);
x->load();
}
else if (algorithm.sbStrcmp(URI_ID_XPF) == 0) {
DSIGTransformXPathFilter * xpf;
XSECnew(xpf, DSIGTransformXPathFilter(env, transforms));
lst->addTransform(xpf);
xpf->load();
}
else if (algorithm.sbStrcmp(URI_ID_ENVELOPE) == 0) {
DSIGTransformEnvelope * e;
XSECnew(e, DSIGTransformEnvelope(env, transforms));
lst->addTransform(e);
e->load();
}
else if (algorithm.sbStrcmp(URI_ID_XSLT) == 0) {
DSIGTransformXSL * x;
XSECnew(x, DSIGTransformXSL(env, transforms));
lst->addTransform(x);
x->load();
}
else if (algorithm.sbStrcmp(URI_ID_C14N_COM) == 0 ||
algorithm.sbStrcmp(URI_ID_C14N_NOC) == 0 ||
algorithm.sbStrcmp(URI_ID_C14N11_COM) == 0 ||
algorithm.sbStrcmp(URI_ID_C14N11_NOC) == 0 ||
algorithm.sbStrcmp(URI_ID_EXC_C14N_COM) == 0 ||
algorithm.sbStrcmp(URI_ID_EXC_C14N_NOC) == 0) {
DSIGTransformC14n * c;
XSECnew(c, DSIGTransformC14n(env, transforms));
lst->addTransform(c);
c->load();
}
else {
// Not what we expected to see!
safeBuffer tmp;
tmp.sbStrcpyIn("Unknown transform : ");
tmp.sbStrcatIn(algorithm);
tmp.sbStrcatIn(" found.");
throw XSECException(XSECException::UnknownTransform, tmp.rawCharBuffer());
}
// Now find next element
transforms = transforms->getNextSibling();
while (transforms != NULL && transforms->getNodeType() != DOMNode::ELEMENT_NODE)
transforms = transforms->getNextSibling();
} /* while (transforms != NULL) */
j_lst.release();
return lst;
}
void DSIGKeyInfoValue::load(void) {
if (mp_valueNode == NULL || !strEquals(getDSIGLocalName(mp_valueNode), "KeyValue")) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Empty or incorrect node passed to DSIGKeyInfoValue");
}
XSECSafeBufferFormatter *formatter;
formatter = mp_parentSignature->getSBFormatter();
DOMNode *child, *p, *val;
child = mp_valueNode->getFirstChild();
while (child != NULL && child->getNodeType() != DOMNode::ELEMENT_NODE)
child = child->getNextSibling();
//child = findFirstChildOfType(mp_valueNode, DOMNode::ELEMENT_NODE);
if (child == 0) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Empty Expected value node beneath <KeyValue>");
}
if (strEquals(getDSIGLocalName(child), "DSAKeyValue")) {
m_keyInfoType = KEYINFO_VALUE_DSA;
p = findFirstChildOfType(child, DOMNode::ELEMENT_NODE);
while (p != NULL) {
if (strEquals(getDSIGLocalName(p), "P")) {
val = findFirstChildOfType(p, DOMNode::TEXT_NODE);
if (val != NULL) {
mp_PTextNode = val;
m_P << (*formatter << val->getNodeValue());
}
}
if (strEquals(getDSIGLocalName(p), "Q")) {
val = findFirstChildOfType(p, DOMNode::TEXT_NODE);
if (val != NULL) {
mp_QTextNode = val;
m_Q << (*formatter << val->getNodeValue());
}
}
if (strEquals(getDSIGLocalName(p), "G")) {
val = findFirstChildOfType(p, DOMNode::TEXT_NODE);
if (val != NULL) {
mp_GTextNode = val;
m_G << (*formatter << val->getNodeValue());
}
}
if (strEquals(getDSIGLocalName(p), "Y")) {
val = findFirstChildOfType(p, DOMNode::TEXT_NODE);
if (val != NULL) {
mp_YTextNode = val;
m_Y << (*formatter << val->getNodeValue());
}
}
p = p->getNextSibling();
}
}
else if (strEquals(getDSIGLocalName(child), "RSAKeyValue")) {
m_keyInfoType = KEYINFO_VALUE_RSA;
p = findFirstChildOfType(child, DOMNode::ELEMENT_NODE);
if (p == 0 || !strEquals(getDSIGLocalName(p), "Modulus")) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <Modulus> node beneath <RSAKeyValue>");
}
val = findFirstChildOfType(p, DOMNode::TEXT_NODE);
if (val == 0) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected a text node beneath <Modulus>");
}
m_modulus << (*formatter << val->getNodeValue());
mp_modulusTextNode = val;
// Find the Exponent
p = p->getNextSibling();
while (p != 0 && p->getNodeType() != DOMNode::ELEMENT_NODE)
p = p->getNextSibling();
if (p == 0 || !strEquals(getDSIGLocalName(p), "Exponent")) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected <Exponent> node beneath <RSAKeyValue>");
}
val = findFirstChildOfType(p, DOMNode::TEXT_NODE);
if (val == 0) {
throw XSECException(XSECException::ExpectedDSIGChildNotFound,
"Expected a text node beneath <Exponent>");
}
m_exponent << (*formatter << val->getNodeValue());
mp_exponentTextNode = val;
}
else {
throw XSECException(XSECException::UnknownKeyValue);
}
}
void XKMSAuthenticationImpl::load(const XMLCh * id) {
if (mp_authenticationElement == NULL) {
throw XSECException(XSECException::ExpectedXKMSChildNotFound,
"XKMSAuthenticationImpl::load - called on empty DOM");
}
// Store for later use
mp_keyBindingId = id;
DOMElement * tmpElt = findFirstElementChild(mp_authenticationElement);
if (tmpElt != NULL && strEquals(getXKMSLocalName(tmpElt),
XKMSConstants::s_tagKeyBindingAuthentication)) {
// Find the signature
mp_keyBindingAuthenticationSignatureElement =
(DOMElement *) findFirstElementChild(tmpElt);
while (mp_keyBindingAuthenticationSignatureElement != NULL &&
!strEquals(getDSIGLocalName(mp_keyBindingAuthenticationSignatureElement),
XKMSConstants::s_tagSignature)) {
mp_keyBindingAuthenticationSignatureElement=
findNextElementChild(mp_keyBindingAuthenticationSignatureElement);
}
// The provider will take care of cleaning this up later.
if (mp_keyBindingAuthenticationSignatureElement != NULL) {
mp_keyBindingAuthenticationSignature = m_prov.newSignatureFromDOM(
mp_keyBindingAuthenticationSignatureElement->getOwnerDocument(),
mp_keyBindingAuthenticationSignatureElement);
mp_keyBindingAuthenticationSignature->load();
// Check the signature is across the correct input
DSIGReferenceList * rl =
mp_keyBindingAuthenticationSignature->getReferenceList();
if (rl->getSize() != 1) {
throw XSECException(XSECException::XKMSError,
"XKMSAuthenticationImpl::load - KeyBindingAuthentication Signature with incorrect number of references found (should be 1)");
}
safeBuffer sb;
sb.sbXMLChIn(DSIGConstants::s_unicodeStrEmpty);
sb.sbXMLChAppendCh(chPound);
sb.sbXMLChCat(mp_keyBindingId);
if (!strEquals(rl->item(0)->getURI(), sb.rawXMLChBuffer())) {
throw XSECException(XSECException::XKMSError,
"XKMSAuthenticationImpl::load - KeyBindingAuthentication Signature refers to incorrect Id (should be for KeyBinding)");
}
// We don't actually check the signature as we have no key material to do so!
}
tmpElt = findNextElementChild(tmpElt);
}
if (tmpElt != NULL && strEquals(getXKMSLocalName(tmpElt),
XKMSConstants::s_tagNotBoundAuthentication)) {
XSECnew(mp_notBoundAuthentication, XKMSNotBoundAuthenticationImpl(mp_env, tmpElt));
mp_notBoundAuthentication->load();
}
}
