You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@santuario.apache.org by sc...@apache.org on 2017/12/13 20:55:20 UTC

svn commit: r1818065 [1/3] - in /santuario/xml-security-cpp/trunk/xsec: dsig/ tools/siginf/ tools/xtest/ transformers/ utils/ xenc/ xenc/impl/ xkms/impl/

Author: scantor
Date: Wed Dec 13 20:55:19 2017
New Revision: 1818065

URL: http://svn.apache.org/viewvc?rev=1818065&view=rev
Log:
Redesign c14n interfaces without enum.

Modified:
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.cpp
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.hpp
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.cpp
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.hpp
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGSignature.cpp
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGSignature.hpp
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGSignedInfo.cpp
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGSignedInfo.hpp
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGTransformC14n.cpp
    santuario/xml-security-cpp/trunk/xsec/dsig/DSIGTransformC14n.hpp
    santuario/xml-security-cpp/trunk/xsec/tools/siginf/siginf.cpp
    santuario/xml-security-cpp/trunk/xsec/tools/xtest/xtest.cpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMBase64.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMC14n.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMChain.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMCipher.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMConcatChains.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMEnvelope.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMOutputFile.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMParser.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMSB.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMURL.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMXPath.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMXPathFilter.hpp
    santuario/xml-security-cpp/trunk/xsec/transformers/TXFMXSL.hpp
    santuario/xml-security-cpp/trunk/xsec/utils/XSECAlgorithmSupport.cpp
    santuario/xml-security-cpp/trunk/xsec/utils/XSECAlgorithmSupport.hpp
    santuario/xml-security-cpp/trunk/xsec/xenc/XENCCipherReference.hpp
    santuario/xml-security-cpp/trunk/xsec/xenc/impl/XENCCipherReferenceImpl.cpp
    santuario/xml-security-cpp/trunk/xsec/xenc/impl/XENCCipherReferenceImpl.hpp
    santuario/xml-security-cpp/trunk/xsec/xkms/impl/XKMSAuthenticationImpl.cpp
    santuario/xml-security-cpp/trunk/xsec/xkms/impl/XKMSMessageAbstractTypeImpl.cpp
    santuario/xml-security-cpp/trunk/xsec/xkms/impl/XKMSRegisterRequestImpl.cpp
    santuario/xml-security-cpp/trunk/xsec/xkms/impl/XKMSReissueRequestImpl.cpp

Modified: santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.cpp
URL: http://svn.apache.org/viewvc/santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.cpp?rev=1818065&r1=1818064&r2=1818065&view=diff
==============================================================================
--- santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.cpp (original)
+++ santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.cpp Wed Dec 13 20:55:19 2017
@@ -568,38 +568,3 @@ bool XSECmapURIToSignatureMethods(const
 	return false;
 
 }
-
-bool XSECmapURIToCanonicalizationMethod(const XMLCh * URI,
-							canonicalizationMethod & cm) {
-
-	// Quick and dirty but inefficient
-	if (strEquals(URI, DSIGConstants::s_unicodeStrURIC14N_NOC)) {
-		cm = CANON_C14N_NOC;
-	}
-	else if (strEquals(URI, DSIGConstants::s_unicodeStrURIC14N_COM)) {
-		cm = CANON_C14N_COM;
-	}
-
-	else if (strEquals(URI, DSIGConstants::s_unicodeStrURIEXC_C14N_COM)) {
-		cm = CANON_C14NE_COM;
-	}
-
-	else if (strEquals(URI, DSIGConstants::s_unicodeStrURIEXC_C14N_NOC)) {
-		cm = CANON_C14NE_NOC;
-	}
-	else if (strEquals(URI, DSIGConstants::s_unicodeStrURIC14N11_NOC)) {
-        cm = CANON_C14N11_NOC;
-    }
-    else if (strEquals(URI, DSIGConstants::s_unicodeStrURIC14N11_COM)) {
-        cm = CANON_C14N11_COM;
-    }
-
-	else {
-
-		// Unknown
-		cm = CANON_NONE;
-		return false;
-	}
-
-	return true;
-}

Modified: santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.hpp
URL: http://svn.apache.org/viewvc/santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.hpp?rev=1818065&r1=1818064&r2=1818065&view=diff
==============================================================================
--- santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.hpp (original)
+++ santuario/xml-security-cpp/trunk/xsec/dsig/DSIGConstants.hpp Wed Dec 13 20:55:19 2017
@@ -159,17 +159,6 @@ XSEC_USING_XERCES(XMLString);
 
 // Enumerated Types
 
-enum canonicalizationMethod {
-
-    CANON_NONE                    = 0,            // No method defined
-    CANON_C14N_NOC                = 1,            // C14n without comments
-    CANON_C14N_COM                = 2,             // C14n with comments
-    CANON_C14NE_NOC                = 3,            // C14n Exclusive (without comments)
-    CANON_C14NE_COM                = 4,            // C14n Exlusive (with Comments
-    CANON_C14N11_NOC            = 5,            // C14n 1.1 without comments
-    CANON_C14N11_COM            = 6             // C14n 1.1 with comments
-};
-
 enum signatureMethod {
 
     SIGNATURE_NONE                = 0,            // No method defined
@@ -188,54 +177,6 @@ enum xpathFilterType {
 };
 
 // --------------------------------------------------------------------------------
-//           Some utility functions
-// --------------------------------------------------------------------------------
-
-inline
-bool canonicalizationMethod2URI(safeBuffer& uri, canonicalizationMethod cm) {
-
-    switch (cm) {
-
-    case (CANON_C14N_NOC) :
-
-        uri = URI_ID_C14N_NOC;
-        break;
-
-    case (CANON_C14N_COM) :
-
-        uri = URI_ID_C14N_COM;
-        break;
-
-    case (CANON_C14NE_NOC) :
-
-        uri = URI_ID_EXC_C14N_NOC;
-        break;
-
-    case (CANON_C14NE_COM) :
-
-        uri = URI_ID_EXC_C14N_COM;
-        break;
-
-    case (CANON_C14N11_NOC) :
-
-        uri = URI_ID_C14N11_NOC;
-        break;
-
-    case (CANON_C14N11_COM) :
-
-        uri = URI_ID_C14N11_COM;
-        break;
-
-    default :
-        return false;        // Unknown type
-
-    }
-
-    return true;
-
-}
-
-// --------------------------------------------------------------------------------
 //           Constant Strings Class
 // --------------------------------------------------------------------------------
 
@@ -351,38 +292,6 @@ public:
 };
 
 
-
-
-inline
-const XMLCh* canonicalizationMethod2UNICODEURI(canonicalizationMethod cm) {
-
-    switch (cm) {
-
-    case (CANON_C14N_NOC) :
-
-        return DSIGConstants::s_unicodeStrURIC14N_NOC;
-
-    case (CANON_C14N_COM) :
-
-        return DSIGConstants::s_unicodeStrURIC14N_COM;
-
-    case (CANON_C14NE_NOC) :
-
-        return DSIGConstants::s_unicodeStrURIEXC_C14N_NOC;
-
-    case (CANON_C14NE_COM) :
-
-        return DSIGConstants::s_unicodeStrURIEXC_C14N_COM;
-
-    default :
-        break;
-
-    }
-
-    return DSIGConstants::s_unicodeStrEmpty;
-
-}
-
 // --------------------------------------------------------------------------------
 //            URI Inverse Mappings
 // --------------------------------------------------------------------------------
@@ -397,7 +306,5 @@ const XMLCh* canonicalizationMethod2UNIC
 bool XSEC_EXPORT XSECmapURIToSignatureMethods(const XMLCh* URI,
                                                   signatureMethod& sm,
                                                   XSECCryptoHash::HashType& type);
-bool XSEC_EXPORT XSECmapURIToCanonicalizationMethod(const XMLCh* URI,
-                            canonicalizationMethod& cm);
 
 #endif /* DSIGCONSTANTS_HEADER */

Modified: santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.cpp
URL: http://svn.apache.org/viewvc/santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.cpp?rev=1818065&r1=1818064&r2=1818065&view=diff
==============================================================================
--- santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.cpp (original)
+++ santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.cpp Wed Dec 13 20:55:19 2017
@@ -248,14 +248,15 @@ DSIGTransformXSL * DSIGReference::append
 
 }
 
-DSIGTransformC14n * DSIGReference::appendCanonicalizationTransform(canonicalizationMethod cm) {
+DSIGTransformC14n * DSIGReference::appendCanonicalizationTransform(
+        const XMLCh * canonicalizationAlgorithmURI) {
 
     DOMElement *txfmElt;
     DSIGTransformC14n * txfm;
 
     XSECnew(txfm, DSIGTransformC14n(mp_env));
     txfmElt = txfm->createBlankTransform(mp_env->getParentDocument());
-    txfm->setCanonicalizationMethod(cm);
+    txfm->setCanonicalizationMethod(canonicalizationAlgorithmURI);
 
     addTransform(txfm, txfmElt);
 
@@ -263,16 +264,6 @@ DSIGTransformC14n * DSIGReference::appen
 
 }
 
-DSIGTransformC14n * DSIGReference::appendCanonicalizationTransform(
-        const XMLCh * canonicalizationAlgorithmURI) {
-
-    canonicalizationMethod cm;
-    XSECmapURIToCanonicalizationMethod(canonicalizationAlgorithmURI, cm);
-
-    return appendCanonicalizationTransform(cm);
-
-}
-
 DSIGTransformXPath * DSIGReference::appendXPathTransform(const char * expr) {
 
     DOMElement *txfmElt;

Modified: santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.hpp
URL: http://svn.apache.org/viewvc/santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.hpp?rev=1818065&r1=1818064&r2=1818065&view=diff
==============================================================================
--- santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.hpp (original)
+++ santuario/xml-security-cpp/trunk/xsec/dsig/DSIGReference.hpp Wed Dec 13 20:55:19 2017
@@ -228,16 +228,6 @@ public:
 	);
 
 	/**
-	 * \brief Append a Canonicalization Transform to the Reference.
-	 *
-	 * @param cm The type of canonicalisation to be added.
-	 * @returns The newly create canonicalisation transform
-	 * @deprecated Use the AlgorithmURI based method instead
-	 */
-
-	DSIGTransformC14n * appendCanonicalizationTransform(canonicalizationMethod cm);
-
-	/**
 	 * \brief Append a "debug" transformer.
 	 *
 	 * This method allows applications to provide a TXFM that will be appended

Modified: santuario/xml-security-cpp/trunk/xsec/dsig/DSIGSignature.cpp
URL: http://svn.apache.org/viewvc/santuario/xml-security-cpp/trunk/xsec/dsig/DSIGSignature.cpp?rev=1818065&r1=1818064&r2=1818065&view=diff
==============================================================================
--- santuario/xml-security-cpp/trunk/xsec/dsig/DSIGSignature.cpp (original)
+++ santuario/xml-security-cpp/trunk/xsec/dsig/DSIGSignature.cpp Wed Dec 13 20:55:19 2017
@@ -20,7 +20,7 @@
 /*
  * XSEC
  *
- * DSIGSignature := Class for checking and setting up signature nodes in a DSIG signature					 
+ * DSIGSignature := Class for checking and setting up signature nodes in a DSIG signature
  *
  * Author(s): Berin Lautenbach
  *
@@ -59,6 +59,8 @@
 #include <xsec/utils/XSECDOMUtils.hpp>
 #include <xsec/utils/XSECPlatformUtils.hpp>
 
+#include "../utils/XSECAlgorithmSupport.hpp"
+
 // Xerces includes
 
 #include <xercesc/dom/DOMNamedNodeMap.hpp>
@@ -71,42 +73,42 @@ XERCES_CPP_NAMESPACE_USE
 // --------------------------------------------------------------------------------
 
 
-void DSIGSignature::Initialise(void) {
+void DSIGSignature::Initialise() {
+
+    DSIGAlgorithmHandlerDefault def;
+
+    // Register default signature algorithm handlers
+
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA1, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_MD5, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA224, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA256, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA384, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA512, def);
 
-	DSIGAlgorithmHandlerDefault def;
-	
-	// Register default signature algorithm handlers
-
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA1, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_MD5, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA224, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA256, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA384, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIRSA_SHA512, def);
-	
     XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIDSA_SHA1, def);
     XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIDSA_SHA256, def);
 
     XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIECDSA_SHA1, def);
     XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIECDSA_SHA224, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIECDSA_SHA256, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIECDSA_SHA384, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIECDSA_SHA512, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIECDSA_SHA256, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIECDSA_SHA384, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIECDSA_SHA512, def);
 
     XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIHMAC_SHA1, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIHMAC_SHA224, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIHMAC_SHA256, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIHMAC_SHA384, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIHMAC_SHA512, def);
-
-	// Register default hashing algorithm handlers
-
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA1, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA224, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA256, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA384, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA512, def);
-	XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIMD5, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIHMAC_SHA224, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIHMAC_SHA256, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIHMAC_SHA384, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIHMAC_SHA512, def);
+
+    // Register default hashing algorithm handlers
+
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA1, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA224, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA256, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA384, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURISHA512, def);
+    XSECPlatformUtils::registerAlgorithmHandler(DSIGConstants::s_unicodeStrURIMD5, def);
 
 }
 
@@ -115,74 +117,53 @@ void DSIGSignature::Initialise(void) {
 //           Get the Canonicalised BYTE_STREAM of the SignedInfo
 // --------------------------------------------------------------------------------
 
-XSECBinTXFMInputStream * DSIGSignature::makeBinInputStream(void) const {
-
-	TXFMBase * txfm;
-
-	// Create the starting point for the transform list
-
-	XSECnew(txfm, TXFMDocObject(mp_doc));
-
-	TXFMChain * chain;
-	XSECnew(chain, TXFMChain(txfm));
-	Janitor<TXFMChain> j_chain(chain);
-
-	((TXFMDocObject *) txfm)->setInput(mp_doc, mp_signedInfo->getDOMNode());
-	
-	// canonicalise the SignedInfo content
-
-	switch (mp_signedInfo->getCanonicalizationMethod()) {
-
-	case CANON_C14N_NOC :
-
-		XSECnew(txfm, TXFMC14n(mp_doc));
-		chain->appendTxfm(txfm);
-		txfm->stripComments();
-		
-		break;
+XSECBinTXFMInputStream* DSIGSignature::makeBinInputStream() const {
 
-	case CANON_C14N_COM :
+    TXFMBase* txfm;
 
-		XSECnew(txfm, TXFMC14n(mp_doc));
-		chain->appendTxfm(txfm);
-		txfm->activateComments();
+    // Create the starting point for the transform list
 
-		break;
+    XSECnew(txfm, TXFMDocObject(mp_doc));
 
-	case CANON_C14NE_NOC :
+    TXFMChain* chain;
+    XSECnew(chain, TXFMChain(txfm));
+    Janitor<TXFMChain> j_chain(chain);
 
-		XSECnew(txfm, TXFMC14n(mp_doc));
-		chain->appendTxfm(txfm);
-		((TXFMC14n *) txfm)->setExclusive();
-		txfm->stripComments();
-		
-		break;
+    ((TXFMDocObject*) txfm)->setInput(mp_doc, mp_signedInfo->getDOMNode());
 
-	case CANON_C14NE_COM :
+    // canonicalize the SignedInfo content
 
-		XSECnew(txfm, TXFMC14n(mp_doc));
-		chain->appendTxfm(txfm);
-		((TXFMC14n *) txfm)->setExclusive();
-		txfm->activateComments();
+    bool exclusive;
+    bool comments;
+    bool onedotone;
+    if (XSECAlgorithmSupport::evalCanonicalizationMethod(mp_signedInfo->getCanonicalizationMethod(),
+            exclusive, comments, onedotone)) {
 
-		break;
+        XSECnew(txfm, TXFMC14n(mp_doc));
+        chain->appendTxfm(txfm);
 
-	default :
+        if (comments)
+            txfm->activateComments();
+        else
+            txfm->stripComments();
 
-		throw XSECException(XSECException::SigVfyError,
-			"Canonicalisation method unknown in DSIGSignature::makeBinInputStream()");
+        if (exclusive)
+            ((TXFMC14n*) txfm)->setExclusive();
 
-	}
+        if (onedotone)
+            ((TXFMC14n*) txfm)->setInclusive11();
 
-	// Now create the InputStream
+    } else {
+        throw XSECException(XSECException::SigVfyError,
+            "Unknown CanonicalizationMethod in DSIGSignature::makeBinInputStream()");
+    }
 
-	XSECBinTXFMInputStream * ret;
+    // Now create the InputStream
 
-	ret = new XSECBinTXFMInputStream(chain);
-	j_chain.release();
-
-	return ret;
+    XSECBinTXFMInputStream* ret = new XSECBinTXFMInputStream(chain);
+    j_chain.release();
 
+    return ret;
 }
 
 
@@ -190,22 +171,16 @@ XSECBinTXFMInputStream * DSIGSignature::
 //           Get the list of references
 // --------------------------------------------------------------------------------
 
-DSIGReferenceList * DSIGSignature::getReferenceList(void) {
-
-	return mp_signedInfo ? mp_signedInfo->getReferenceList() : NULL;
-
+DSIGReferenceList* DSIGSignature::getReferenceList() {
+    return mp_signedInfo ? mp_signedInfo->getReferenceList() : NULL;
 }
 
-const DSIGReferenceList * DSIGSignature::getReferenceList(void) const {
-
-	return mp_signedInfo ? mp_signedInfo->getReferenceList() : NULL;
-
+const DSIGReferenceList* DSIGSignature::getReferenceList() const {
+    return mp_signedInfo ? mp_signedInfo->getReferenceList() : NULL;
 }
 
-const XMLCh * DSIGSignature::getAlgorithmURI() const {
-
+const XMLCh* DSIGSignature::getAlgorithmURI() const {
     return mp_signedInfo ? mp_signedInfo->getAlgorithmURI() : NULL;
-
 }
 
 // --------------------------------------------------------------------------------
@@ -213,78 +188,67 @@ const XMLCh * DSIGSignature::getAlgorith
 // --------------------------------------------------------------------------------
 
 
-void DSIGSignature::setURIResolver(XSECURIResolver * resolver) {
-
-	mp_env->setURIResolver(resolver);
-
+void DSIGSignature::setURIResolver(XSECURIResolver* resolver) {
+    mp_env->setURIResolver(resolver);
 }
 
-XSECURIResolver * DSIGSignature::getURIResolver(void) const {
-
-	return mp_env->getURIResolver();
-
+XSECURIResolver* DSIGSignature::getURIResolver() const {
+    return mp_env->getURIResolver();
 }
 
-void DSIGSignature::setKeyInfoResolver(XSECKeyInfoResolver * resolver) {
-
-	if (mp_KeyInfoResolver != 0)
-		delete mp_KeyInfoResolver;
+void DSIGSignature::setKeyInfoResolver(XSECKeyInfoResolver* resolver) {
 
-	mp_KeyInfoResolver = resolver->clone();
+    if (mp_KeyInfoResolver != 0)
+        delete mp_KeyInfoResolver;
 
+    mp_KeyInfoResolver = resolver->clone();
 }
 
-XSECKeyInfoResolver * DSIGSignature::getKeyInfoResolver(void) const {
-
-	return mp_KeyInfoResolver;
-
+XSECKeyInfoResolver* DSIGSignature::getKeyInfoResolver() const {
+    return mp_KeyInfoResolver;
 }
 
 // --------------------------------------------------------------------------------
 //           Object Handling
 // --------------------------------------------------------------------------------
 
-DSIGObject * DSIGSignature::appendObject(void) {
+DSIGObject* DSIGSignature::appendObject() {
 
-	DSIGObject * ret;
-	XSECnew(ret, DSIGObject(mp_env));
-	DOMElement * elt = ret->createBlankObject();
+    DSIGObject* ret;
+    XSECnew(ret, DSIGObject(mp_env));
+    DOMElement* elt = ret->createBlankObject();
 
-	mp_sigNode->appendChild(elt);
-	mp_env->doPrettyPrint(mp_sigNode);
+    mp_sigNode->appendChild(elt);
+    mp_env->doPrettyPrint(mp_sigNode);
 
-	m_objects.push_back(ret);
+    m_objects.push_back(ret);
 
-	return ret;
+    return ret;
 
 }
 
-int DSIGSignature::getObjectLength(void) const {
-
-	return (unsigned int) m_objects.size();
-
+int DSIGSignature::getObjectLength() const {
+    return (unsigned int) m_objects.size();
 }
 
-DSIGObject * DSIGSignature::getObjectItem(int i) {
-
-	if ( i < 0 || i >= ((int) m_objects.size())) {
-		throw XSECException(XSECException::ObjectError,
-			"DSIGSignature::getObjectItem - index out of range");
-	}
+DSIGObject* DSIGSignature::getObjectItem(int i) {
 
-	return m_objects[i];
+    if ( i < 0 || i >= ((int) m_objects.size())) {
+        throw XSECException(XSECException::ObjectError,
+            "DSIGSignature::getObjectItem - index out of range");
+    }
 
+    return m_objects[i];
 }
 
-const DSIGObject * DSIGSignature::getObjectItem(int i) const {
-
-	if ( i < 0 || i >= ((int) m_objects.size())) {
-		throw XSECException(XSECException::ObjectError,
-			"DSIGSignature::getObjectItem - index out of range");
-	}
+const DSIGObject* DSIGSignature::getObjectItem(int i) const {
 
-	return m_objects[i];
+    if ( i < 0 || i >= ((int) m_objects.size())) {
+        throw XSECException(XSECException::ObjectError,
+            "DSIGSignature::getObjectItem - index out of range");
+    }
 
+    return m_objects[i];
 }
 
 // --------------------------------------------------------------------------------
@@ -293,96 +257,91 @@ const DSIGObject * DSIGSignature::getObj
 
 // Constructors and Destructors
 
-DSIGSignature::DSIGSignature(DOMDocument *doc, DOMNode *sigNode) :
-		m_loaded(false),
-		mp_doc(doc),
-		mp_sigNode(sigNode),
-		mp_signedInfo(NULL),
-		mp_signatureValueNode(NULL),
-		m_keyInfoList(NULL),
-		mp_KeyInfoNode(NULL),
-		m_errStr(""),
-		mp_signingKey(NULL),
-		mp_KeyInfoResolver(NULL),
-		m_interlockingReferences(false) {
-
-	// Set up our formatter
-	XSECnew(mp_formatter, XSECSafeBufferFormatter("UTF-8",XMLFormatter::NoEscapes, 
-												XMLFormatter::UnRep_CharRef));
-
-	// Set up the environment
-	XSECnew(mp_env, XSECEnv(doc));
-
-	m_keyInfoList.setEnvironment(mp_env);
+DSIGSignature::DSIGSignature(DOMDocument* doc, DOMNode* sigNode) :
+        m_loaded(false),
+        mp_doc(doc),
+        mp_sigNode(sigNode),
+        mp_signedInfo(NULL),
+        mp_signatureValueNode(NULL),
+        m_keyInfoList(NULL),
+        mp_KeyInfoNode(NULL),
+        m_errStr(""),
+        mp_signingKey(NULL),
+        mp_KeyInfoResolver(NULL),
+        m_interlockingReferences(false) {
+
+    // Set up our formatter
+    XSECnew(mp_formatter, XSECSafeBufferFormatter("UTF-8",XMLFormatter::NoEscapes,
+                                                XMLFormatter::UnRep_CharRef));
+
+    // Set up the environment
+    XSECnew(mp_env, XSECEnv(doc));
+
+    m_keyInfoList.setEnvironment(mp_env);
+}
+
+DSIGSignature::DSIGSignature() :
+        m_loaded(false),
+        mp_doc(NULL),
+        mp_sigNode(NULL),
+        mp_signedInfo(NULL),
+        mp_signatureValueNode(NULL),
+        m_keyInfoList(NULL),
+        mp_KeyInfoNode(NULL),
+        m_errStr(""),
+        mp_signingKey(NULL),
+        mp_KeyInfoResolver(NULL),
+        m_interlockingReferences(false) {
+
+    // Set up our formatter
+    XSECnew(mp_formatter, XSECSafeBufferFormatter("UTF-8",XMLFormatter::NoEscapes,
+                                                XMLFormatter::UnRep_CharRef));
 
-}
-
-DSIGSignature::DSIGSignature(void) :
-		m_loaded(false),
-		mp_doc(NULL),
-		mp_sigNode(NULL),
-		mp_signedInfo(NULL),
-		mp_signatureValueNode(NULL),
-		m_keyInfoList(NULL),
-		mp_KeyInfoNode(NULL),
-		m_errStr(""),
-		mp_signingKey(NULL),
-		mp_KeyInfoResolver(NULL),
-		m_interlockingReferences(false) {
-
-	// Set up our formatter
-	XSECnew(mp_formatter, XSECSafeBufferFormatter("UTF-8",XMLFormatter::NoEscapes, 
-												XMLFormatter::UnRep_CharRef));
-
-	XSECnew(mp_env, XSECEnv(NULL));
-
-	m_keyInfoList.setEnvironment(mp_env);
+    XSECnew(mp_env, XSECEnv(NULL));
 
+    m_keyInfoList.setEnvironment(mp_env);
 }
 
 DSIGSignature::~DSIGSignature() {
 
-	if (mp_env != NULL)
-		delete mp_env;
-
-	if (mp_signingKey != NULL) {
+    if (mp_env != NULL)
+        delete mp_env;
 
-		delete mp_signingKey;
-		mp_signingKey = NULL;
+    if (mp_signingKey != NULL) {
 
-	}
+        delete mp_signingKey;
+        mp_signingKey = NULL;
 
-	if (mp_signedInfo != NULL) {
+    }
 
-		delete mp_signedInfo;
-		mp_signedInfo = NULL;
+    if (mp_signedInfo != NULL) {
 
-	}
+        delete mp_signedInfo;
+        mp_signedInfo = NULL;
 
-	if (mp_formatter != NULL) {
+    }
 
-		delete mp_formatter;
-		mp_formatter = NULL;
-	}
+    if (mp_formatter != NULL) {
 
-	if (mp_KeyInfoResolver != NULL) {
-		delete mp_KeyInfoResolver;
-		mp_KeyInfoResolver = NULL;
-	}
+        delete mp_formatter;
+        mp_formatter = NULL;
+    }
 
-	// Delete any object items
-	for (int i = 0; i < ((int) m_objects.size()); ++i) {
-		delete (m_objects[i]);
-	}
+    if (mp_KeyInfoResolver != NULL) {
+        delete mp_KeyInfoResolver;
+        mp_KeyInfoResolver = NULL;
+    }
 
+    // Delete any object items
+    for (int i = 0; i < ((int) m_objects.size()); ++i) {
+        delete (m_objects[i]);
+    }
 }
 
 // Actions
 
-const XMLCh * DSIGSignature::getErrMsgs() const {
-
-	return m_errStr.rawXMLChBuffer();
-
+const XMLCh* DSIGSignature::getErrMsgs() const {
+    return m_errStr.rawXMLChBuffer();
 }
 
 // --------------------------------------------------------------------------------
@@ -390,117 +349,101 @@ const XMLCh * DSIGSignature::getErrMsgs(
 // --------------------------------------------------------------------------------
 
 void DSIGSignature::setPrettyPrint(bool flag) {
-
-	mp_env->setPrettyPrintFlag(flag);
-
+    mp_env->setPrettyPrintFlag(flag);
 }
 
 
-bool DSIGSignature::getPrettyPrint(void) const {
-
-	return mp_env->getPrettyPrintFlag();
-
+bool DSIGSignature::getPrettyPrint() const {
+    return mp_env->getPrettyPrintFlag();
 }
 
 // --------------------------------------------------------------------------------
 //           Creating signatures from blank
 // --------------------------------------------------------------------------------
 
-void DSIGSignature::setDSIGNSPrefix(const XMLCh * prefix) {
-
-	mp_env->setDSIGNSPrefix(prefix);
-
+void DSIGSignature::setDSIGNSPrefix(const XMLCh* prefix) {
+    mp_env->setDSIGNSPrefix(prefix);
 }
 
-void DSIGSignature::setECNSPrefix(const XMLCh * prefix) {
-
-	mp_env->setECNSPrefix(prefix);
-
+void DSIGSignature::setECNSPrefix(const XMLCh* prefix) {
+    mp_env->setECNSPrefix(prefix);
 }
 
-void DSIGSignature::setXPFNSPrefix(const XMLCh * prefix) {
-
-	mp_env->setXPFNSPrefix(prefix);
-
+void DSIGSignature::setXPFNSPrefix(const XMLCh* prefix) {
+    mp_env->setXPFNSPrefix(prefix);
 }
 
 // get
 
-const XMLCh * DSIGSignature::getDSIGNSPrefix() const {
-
-	return mp_env->getDSIGNSPrefix();
-
+const XMLCh* DSIGSignature::getDSIGNSPrefix() const {
+    return mp_env->getDSIGNSPrefix();
 }
 
 
-const XMLCh * DSIGSignature::getECNSPrefix() const {
-
-	return mp_env->getECNSPrefix();
-
+const XMLCh* DSIGSignature::getECNSPrefix() const {
+    return mp_env->getECNSPrefix();
 }
 
-const XMLCh * DSIGSignature::getXPFNSPrefix() const {
+const XMLCh* DSIGSignature::getXPFNSPrefix() const {
+    return mp_env->getXPFNSPrefix();
+}
 
-	return mp_env->getXPFNSPrefix();
+DOMElement*DSIGSignature::createBlankSignature(
+        DOMDocument* doc,
+        const XMLCh* canonicalizationAlgorithmURI,
+        const XMLCh* signatureAlgorithmURI) {
 
-}
+    // "New" method to create a blank signature, based on URIs.
 
-DOMElement *DSIGSignature::createBlankSignature(
-		DOMDocument *doc,
-		const XMLCh * canonicalizationAlgorithmURI,
-		const XMLCh * signatureAlgorithmURI) {
+    mp_doc = doc;
+    mp_env->setParentDocument(doc);
 
-	// "New" method to create a blank signature, based on URIs.
+    const XMLCh* prefixNS = mp_env->getDSIGNSPrefix();
 
-	mp_doc = doc;
-	mp_env->setParentDocument(doc);
+    safeBuffer str;
 
-	const XMLCh * prefixNS = mp_env->getDSIGNSPrefix();
+    makeQName(str, prefixNS, "Signature");
 
-	safeBuffer str;
+    DOMElement*sigNode = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
 
-	makeQName(str, prefixNS, "Signature");
+    if (prefixNS[0] == '\0') {
+        str.sbTranscodeIn("xmlns");
+    }
+    else {
+        str.sbTranscodeIn("xmlns:");
+        str.sbXMLChCat(prefixNS);
+    }
 
-	DOMElement *sigNode = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, str.rawXMLChBuffer());
+    sigNode->setAttributeNS(DSIGConstants::s_unicodeStrURIXMLNS,
+                            str.rawXMLChBuffer(),
+                            DSIGConstants::s_unicodeStrURIDSIG);
 
-	if (prefixNS[0] == '\0') {
-		str.sbTranscodeIn("xmlns");
-	}
-	else {
-		str.sbTranscodeIn("xmlns:");
-		str.sbXMLChCat(prefixNS);
-	}
+    mp_sigNode = sigNode;
 
-	sigNode->setAttributeNS(DSIGConstants::s_unicodeStrURIXMLNS, 
-							str.rawXMLChBuffer(), 
-							DSIGConstants::s_unicodeStrURIDSIG);
+    mp_env->doPrettyPrint(mp_sigNode);
 
-	mp_sigNode = sigNode;
+    // Create the skeleton SignedInfo
+    XSECnew(mp_signedInfo, DSIGSignedInfo(mp_doc, mp_formatter, mp_env));
 
-	mp_env->doPrettyPrint(mp_sigNode);
+    mp_sigNode->appendChild(mp_signedInfo->createBlankSignedInfo(
+        canonicalizationAlgorithmURI, signatureAlgorithmURI));
+    mp_env->doPrettyPrint(mp_sigNode);
 
-	// Create the skeleton SignedInfo
-	XSECnew(mp_signedInfo, DSIGSignedInfo(mp_doc, mp_formatter, mp_env));
-	
-	mp_sigNode->appendChild(mp_signedInfo->createBlankSignedInfo(
-		canonicalizationAlgorithmURI, signatureAlgorithmURI));
-	mp_env->doPrettyPrint(mp_sigNode);
+    // Create a dummy signature value (dummy until signed)
 
-	// Create a dummy signature value (dummy until signed)
+    makeQName(str, mp_env->getDSIGNSPrefix(), "SignatureValue");
+    DOMElement*sigValNode = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG,
+                                                  str.rawXMLChBuffer());
+    mp_signatureValueNode = sigValNode;
+    mp_sigNode->appendChild(sigValNode);
+    mp_env->doPrettyPrint(mp_sigNode);
 
-	makeQName(str, mp_env->getDSIGNSPrefix(), "SignatureValue");
-	DOMElement *sigValNode = doc->createElementNS(DSIGConstants::s_unicodeStrURIDSIG, 
-												  str.rawXMLChBuffer());
-	mp_signatureValueNode = sigValNode;
-	mp_sigNode->appendChild(sigValNode);
-	mp_env->doPrettyPrint(mp_sigNode);
+    // Some text to mark this as a template only
+    sigValNode->appendChild(doc->createTextNode(MAKE_UNICODE_STRING("Not yet signed")));
 
-	// Some text to mark this as a template only
-	sigValNode->appendChild(doc->createTextNode(MAKE_UNICODE_STRING("Not yet signed")));
+    m_loaded = true;
 
-	m_loaded = true;
-	
-	return sigNode;
+    return sigNode;
 }
 
 
@@ -509,16 +452,15 @@ DOMElement *DSIGSignature::createBlankSi
 //           Creating References
 // --------------------------------------------------------------------------------
 
-DSIGReference * DSIGSignature::createReference(
-		const XMLCh * URI,
-		const XMLCh * hashAlgorithmURI, 
-		const XMLCh * type) {
-
-	return mp_signedInfo->createReference(URI, hashAlgorithmURI, type);
+DSIGReference* DSIGSignature::createReference(
+        const XMLCh* URI,
+        const XMLCh* hashAlgorithmURI,
+        const XMLCh* type) {
 
+    return mp_signedInfo->createReference(URI, hashAlgorithmURI, type);
 }
 
-DSIGReference * DSIGSignature::removeReference(DSIGReferenceList::size_type index) {
+DSIGReference* DSIGSignature::removeReference(DSIGReferenceList::size_type index) {
     return mp_signedInfo ? mp_signedInfo->removeReference(index) : NULL;
 }
 
@@ -526,109 +468,101 @@ DSIGReference * DSIGSignature::removeRef
 //           Manipulation of KeyInfo elements
 // --------------------------------------------------------------------------------
 
-void DSIGSignature::clearKeyInfo(void) {
+void DSIGSignature::clearKeyInfo() {
 
-	if (mp_KeyInfoNode == 0)
-		return;
+    if (mp_KeyInfoNode == 0)
+        return;
 
-	if (mp_sigNode->removeChild(mp_KeyInfoNode) != mp_KeyInfoNode) {
+    if (mp_sigNode->removeChild(mp_KeyInfoNode) != mp_KeyInfoNode) {
 
-		throw XSECException(XSECException::ExpectedDSIGChildNotFound,
-			"Attempted to remove KeyInfo node but it is no longer a child of <Signature>");
+        throw XSECException(XSECException::ExpectedDSIGChildNotFound,
+            "Attempted to remove KeyInfo node but it is no longer a child of <Signature>");
 
-	}
+    }
 
-	mp_KeyInfoNode->release();		// No longer required
+    mp_KeyInfoNode->release();        // No longer required
 
-	mp_KeyInfoNode = NULL;
+    mp_KeyInfoNode = NULL;
 
-	// Clear out the list
-	m_keyInfoList.empty();
+    // Clear out the list
+    m_keyInfoList.empty();
 
 }
 
-void DSIGSignature::createKeyInfoElement(void) {
+void DSIGSignature::createKeyInfoElement() {
 
-	if (mp_KeyInfoNode != NULL)
-		return;
+    if (mp_KeyInfoNode != NULL)
+        return;
 
-	safeBuffer str;
+    safeBuffer str;
 
-	makeQName(str, mp_env->getDSIGNSPrefix(), "KeyInfo");
+    makeQName(str, mp_env->getDSIGNSPrefix(), "KeyInfo");
 
-	mp_KeyInfoNode = m_keyInfoList.createKeyInfo();
+    mp_KeyInfoNode = m_keyInfoList.createKeyInfo();
 
-	// Append the node to the end of the signature
-	
-	DOMNode * afterSignatureValue = mp_signatureValueNode->getNextSibling();
-	while (afterSignatureValue != 0 && afterSignatureValue->getNodeType() != DOMNode::ELEMENT_NODE)
-		afterSignatureValue = afterSignatureValue->getNextSibling();
+    // Append the node to the end of the signature
 
-	if (afterSignatureValue == 0) {
-		mp_sigNode->appendChild(mp_KeyInfoNode);
-		mp_env->doPrettyPrint(mp_sigNode);
-	}
-	else {
-		mp_sigNode->insertBefore(mp_KeyInfoNode, afterSignatureValue);
-		if (mp_env->getPrettyPrintFlag() == true)
-			mp_sigNode->insertBefore(mp_doc->createTextNode(DSIGConstants::s_unicodeStrNL),
-				afterSignatureValue);
-	}
+    DOMNode* afterSignatureValue = mp_signatureValueNode->getNextSibling();
+    while (afterSignatureValue != 0 && afterSignatureValue->getNodeType() != DOMNode::ELEMENT_NODE)
+        afterSignatureValue = afterSignatureValue->getNextSibling();
 
+    if (afterSignatureValue == 0) {
+        mp_sigNode->appendChild(mp_KeyInfoNode);
+        mp_env->doPrettyPrint(mp_sigNode);
+    }
+    else {
+        mp_sigNode->insertBefore(mp_KeyInfoNode, afterSignatureValue);
+        if (mp_env->getPrettyPrintFlag() == true)
+            mp_sigNode->insertBefore(mp_doc->createTextNode(DSIGConstants::s_unicodeStrNL),
+                afterSignatureValue);
+    }
 }
 
-DSIGKeyInfoValue * DSIGSignature::appendDSAKeyValue(const XMLCh * P, 
-						   const XMLCh * Q, 
-						   const XMLCh * G, 
-						   const XMLCh * Y) {
-
-	createKeyInfoElement();
-	return m_keyInfoList.appendDSAKeyValue(P, Q, G, Y);
+DSIGKeyInfoValue* DSIGSignature::appendDSAKeyValue(const XMLCh* P,
+                           const XMLCh* Q,
+                           const XMLCh* G,
+                           const XMLCh* Y) {
 
+    createKeyInfoElement();
+    return m_keyInfoList.appendDSAKeyValue(P, Q, G, Y);
 }
 
-DSIGKeyInfoValue * DSIGSignature::appendRSAKeyValue(const XMLCh * modulus, 
-						   const XMLCh * exponent) {
-
-	createKeyInfoElement();
-	return m_keyInfoList.appendRSAKeyValue(modulus, exponent);
+DSIGKeyInfoValue* DSIGSignature::appendRSAKeyValue(const XMLCh* modulus,
+                           const XMLCh* exponent) {
 
+    createKeyInfoElement();
+    return m_keyInfoList.appendRSAKeyValue(modulus, exponent);
 }
 
 
-DSIGKeyInfoX509 * DSIGSignature::appendX509Data(void) {
-
-	createKeyInfoElement();
-	return m_keyInfoList.appendX509Data();
+DSIGKeyInfoX509* DSIGSignature::appendX509Data() {
 
+    createKeyInfoElement();
+    return m_keyInfoList.appendX509Data();
 }
 
-DSIGKeyInfoName * DSIGSignature::appendKeyName(const XMLCh * name, bool isDName) {
-
-	createKeyInfoElement();
-	return m_keyInfoList.appendKeyName(name, isDName);
+DSIGKeyInfoName* DSIGSignature::appendKeyName(const XMLCh* name, bool isDName) {
 
+    createKeyInfoElement();
+    return m_keyInfoList.appendKeyName(name, isDName);
 }
 
-DSIGKeyInfoPGPData * DSIGSignature::appendPGPData(const XMLCh * id, const XMLCh * packet) {
-
-	createKeyInfoElement();
-	return m_keyInfoList.appendPGPData(id, packet);
+DSIGKeyInfoPGPData* DSIGSignature::appendPGPData(const XMLCh* id, const XMLCh* packet) {
 
+    createKeyInfoElement();
+    return m_keyInfoList.appendPGPData(id, packet);
 }
 
-DSIGKeyInfoSPKIData * DSIGSignature::appendSPKIData(const XMLCh * sexp) {
-
-	createKeyInfoElement();
-	return m_keyInfoList.appendSPKIData(sexp);
+DSIGKeyInfoSPKIData* DSIGSignature::appendSPKIData(const XMLCh* sexp) {
 
+    createKeyInfoElement();
+    return m_keyInfoList.appendSPKIData(sexp);
 }
 
-DSIGKeyInfoMgmtData * DSIGSignature::appendMgmtData(const XMLCh * data) {
-
-	createKeyInfoElement();
-	return m_keyInfoList.appendMgmtData(data);
+DSIGKeyInfoMgmtData* DSIGSignature::appendMgmtData(const XMLCh* data) {
 
+    createKeyInfoElement();
+    return m_keyInfoList.appendMgmtData(data);
 }
 
 // --------------------------------------------------------------------------------
@@ -636,428 +570,398 @@ DSIGKeyInfoMgmtData * DSIGSignature::app
 // --------------------------------------------------------------------------------
 
 
-void DSIGSignature::load(void) {
+void DSIGSignature::load() {
+
+    // Load all the information from the source document into local variables for easier
+    // manipulation by the other functions in the class
 
-	// Load all the information from the source document into local variables for easier
-	// manipulation by the other functions in the class
+    if (mp_sigNode == NULL) {
 
-	if (mp_sigNode == NULL) {
+        // Attempt to load an empty signature element
+        throw XSECException(XSECException::LoadEmptySignature);
 
-		// Attempt to load an empty signature element
-		throw XSECException(XSECException::LoadEmptySignature);
+    }
 
-	}
+    if (!strEquals(getDSIGLocalName(mp_sigNode), "Signature")) {
 
-	if (!strEquals(getDSIGLocalName(mp_sigNode), "Signature")) {
+        throw XSECException(XSECException::LoadNonSignature);
 
-		throw XSECException(XSECException::LoadNonSignature);
+    }
 
-	}
+    m_loaded = true;
 
-	m_loaded = true;
+    // Find the prefix being used so that we can later use it to manipulate the signature
+    mp_env->setDSIGNSPrefix(mp_sigNode->getPrefix());
 
-	// Find the prefix being used so that we can later use it to manipulate the signature
-	mp_env->setDSIGNSPrefix(mp_sigNode->getPrefix());
+    // Now check for SignedInfo
+    DOMNode*tmpElt = mp_sigNode->getFirstChild();
 
-	// Now check for SignedInfo
-	DOMNode *tmpElt = mp_sigNode->getFirstChild();
+    while (tmpElt != 0 && (tmpElt->getNodeType() != DOMNode::ELEMENT_NODE))
+        // Skip text and comments
+        tmpElt = tmpElt->getNextSibling();
 
-	while (tmpElt != 0 && (tmpElt->getNodeType() != DOMNode::ELEMENT_NODE))
-		// Skip text and comments
-		tmpElt = tmpElt->getNextSibling();
+    if (tmpElt == 0 || !strEquals(getDSIGLocalName(tmpElt), "SignedInfo")) {
 
-	if (tmpElt == 0 || !strEquals(getDSIGLocalName(tmpElt), "SignedInfo")) {
+            throw XSECException(XSECException::ExpectedDSIGChildNotFound,
+                    "Expected <SignedInfo> as first child of <Signature>");
 
-			throw XSECException(XSECException::ExpectedDSIGChildNotFound, 
-					"Expected <SignedInfo> as first child of <Signature>");
+    }
 
-	}
+    // Have a signed info
 
-	// Have a signed info
+    XSECnew(mp_signedInfo, DSIGSignedInfo(mp_doc, mp_formatter, tmpElt, mp_env));
+    mp_signedInfo->load();
 
-	XSECnew(mp_signedInfo, DSIGSignedInfo(mp_doc, mp_formatter, tmpElt, mp_env));
-	mp_signedInfo->load();
+    // Look at Signature Value
+    tmpElt = findNextElementChild(tmpElt);
+    if (tmpElt == 0 || !strEquals(getDSIGLocalName(tmpElt), "SignatureValue")) {
 
-	// Look at Signature Value
-	tmpElt = findNextElementChild(tmpElt);
-	if (tmpElt == 0 || !strEquals(getDSIGLocalName(tmpElt), "SignatureValue")) {
+        throw XSECException(XSECException::ExpectedDSIGChildNotFound,
+            "Expected <SignatureValue> node");
 
-		throw XSECException(XSECException::ExpectedDSIGChildNotFound,
-			"Expected <SignatureValue> node");
+    }
 
-	}
+    DOMNode*tmpSV = tmpElt->getFirstChild();
+    while (tmpSV != 0 && tmpSV->getNodeType() != DOMNode::TEXT_NODE)
+        tmpSV = tmpSV->getNextSibling();
 
-	DOMNode *tmpSV = tmpElt->getFirstChild();
-	while (tmpSV != 0 && tmpSV->getNodeType() != DOMNode::TEXT_NODE)
-		tmpSV = tmpSV->getNextSibling();
+    if (tmpSV == 0)
+        throw XSECException(XSECException::ExpectedDSIGChildNotFound,
+        "Expected TEXT child of <SignatureValue>");
 
-	if (tmpSV == 0)
-		throw XSECException(XSECException::ExpectedDSIGChildNotFound,
-		"Expected TEXT child of <SignatureValue>");
+    mp_signatureValueNode = tmpElt;
 
-	mp_signatureValueNode = tmpElt;
-	
-	// The signature value is transcoded to local code page, as it is easier
-	// to work with, and should be low ASCII in any case (Base64)
+    // The signature value is transcoded to local code page, as it is easier
+    // to work with, and should be low ASCII in any case (Base64)
 
-	m_signatureValueSB.sbTranscodeIn(tmpSV->getNodeValue());
+    m_signatureValueSB.sbTranscodeIn(tmpSV->getNodeValue());
 
 
-	// Now look at KeyInfo
-	tmpElt = findNextElementChild(tmpElt);
+    // Now look at KeyInfo
+    tmpElt = findNextElementChild(tmpElt);
 
-	if (tmpElt != 0 && strEquals(getDSIGLocalName(tmpElt), "KeyInfo")) {
+    if (tmpElt != 0 && strEquals(getDSIGLocalName(tmpElt), "KeyInfo")) {
 
-		// Have a keyInfo
+        // Have a keyInfo
 
-		mp_KeyInfoNode = tmpElt;		// In case we later want to manipulate it
+        mp_KeyInfoNode = tmpElt;        // In case we later want to manipulate it
 
-		m_keyInfoList.loadListFromXML(tmpElt);
+        m_keyInfoList.loadListFromXML(tmpElt);
 
-		tmpElt = findNextElementChild(tmpElt);
-	}
+        tmpElt = findNextElementChild(tmpElt);
+    }
 
-	while (tmpElt != 0 && strEquals(getDSIGLocalName(tmpElt), "Object")) {
+    while (tmpElt != 0 && strEquals(getDSIGLocalName(tmpElt), "Object")) {
 
-		DSIGObject * obj;
-		XSECnew(obj, DSIGObject(mp_env, tmpElt));
-		obj->load();
+        DSIGObject* obj;
+        XSECnew(obj, DSIGObject(mp_env, tmpElt));
+        obj->load();
 
-		m_objects.push_back(obj);
+        m_objects.push_back(obj);
 
-		tmpElt = findNextElementChild(tmpElt);
+        tmpElt = findNextElementChild(tmpElt);
 
-	}
+    }
 /*
-	* Strictly speaking, this should remain, but it causes too many problems with non
-	* conforming signatures
+    * Strictly speaking, this should remain, but it causes too many problems with non
+    * conforming signatures
 
-	if (tmpElt != 0) {
-		throw XSECException(XSECException::ExpectedDSIGChildNotFound, 
-			"DSIGSignature::load - Unexpected (non Object) Element found at end of signature");
-	}
+    if (tmpElt != 0) {
+        throw XSECException(XSECException::ExpectedDSIGChildNotFound,
+            "DSIGSignature::load - Unexpected (non Object) Element found at end of signature");
+    }
 */
 }
 
-TXFMChain * DSIGSignature::getSignedInfoInput(void) const {
-
-	TXFMBase * txfm;
-	TXFMChain * chain;
-
-	// First we calculate the hash.  Start off by creating a starting point
-	XSECnew(txfm, TXFMDocObject(mp_doc));
-	XSECnew(chain, TXFMChain(txfm));
-	Janitor<TXFMChain> j_chain(chain);
-
-	((TXFMDocObject *) txfm)->setInput(mp_doc, mp_signedInfo->getDOMNode());
-	
-	// canonicalise the SignedInfo content
+TXFMChain* DSIGSignature::getSignedInfoInput() const {
 
-	switch (mp_signedInfo->getCanonicalizationMethod()) {
+    TXFMBase* txfm;
+    TXFMChain* chain;
 
-	case CANON_C14N_NOC :
+    // First we calculate the hash.  Start off by creating a starting point
+    XSECnew(txfm, TXFMDocObject(mp_doc));
+    XSECnew(chain, TXFMChain(txfm));
+    Janitor<TXFMChain> j_chain(chain);
 
-		XSECnew(txfm, TXFMC14n(mp_doc));
-		chain->appendTxfm(txfm);
-		txfm->stripComments();
-		
-		break;
+    ((TXFMDocObject*) txfm)->setInput(mp_doc, mp_signedInfo->getDOMNode());
 
-	case CANON_C14N_COM :
+    // canonicalise the SignedInfo content
 
-		XSECnew(txfm, TXFMC14n(mp_doc));
-		chain->appendTxfm(txfm);
-		txfm->activateComments();
+    bool exclusive;
+    bool comments;
+    bool onedotone;
+    if (XSECAlgorithmSupport::evalCanonicalizationMethod(mp_signedInfo->getCanonicalizationMethod(),
+            exclusive, comments, onedotone)) {
 
-		break;
+        XSECnew(txfm, TXFMC14n(mp_doc));
+        chain->appendTxfm(txfm);
 
-	case CANON_C14NE_NOC :
+        if (comments)
+            txfm->activateComments();
+        else
+            txfm->stripComments();
 
-		XSECnew(txfm, TXFMC14n(mp_doc));
-		chain->appendTxfm(txfm);
-		((TXFMC14n *) txfm)->setExclusive();
-		txfm->stripComments();
-		
-		break;
+        if (exclusive)
+            ((TXFMC14n*) txfm)->setExclusive();
 
-	case CANON_C14NE_COM :
+        if (onedotone)
+            ((TXFMC14n*) txfm)->setInclusive11();
 
-		XSECnew(txfm, TXFMC14n(mp_doc));
-		chain->appendTxfm(txfm);
-		((TXFMC14n *) txfm)->setExclusive();
-		txfm->activateComments();
-
-		break;
-
-	default :
-
-		throw XSECException(XSECException::SigVfyError,
-			"Canonicalisation method unknown in DSIGSignature::calculateSignedInfoHash()");
-
-	}
-	
-	j_chain.release();
-	return chain;
+    } else {
+        throw XSECException(XSECException::SigVfyError,
+            "Unknown CanonicalizationMethod in DSIGSignature::calculateSignedInfoHash()");
+    }
 
+    j_chain.release();
+    return chain;
 }
 
-unsigned int DSIGSignature::calculateSignedInfoHash(unsigned char * hashBuf, 
-													unsigned int hashBufLen) const {
-
-	// Get the SignedInfo input bytes
-	TXFMChain * chain = getSignedInfoInput();
-	Janitor<TXFMChain> j_chain(chain);
-
-	// Check for debugging sink for the data
-	TXFMBase* sink = XSECPlatformUtils::GetReferenceLoggingSink(mp_doc);
-	if (sink)
-		chain->appendTxfm(sink);
+unsigned int DSIGSignature::calculateSignedInfoHash(unsigned char* hashBuf,
+                                                    unsigned int hashBufLen) const {
 
-	// Setup Hash
-	// First find the appropriate handler for the URI
-	XSECAlgorithmHandler * handler = 
-		XSECPlatformUtils::g_algorithmMapper->mapURIToHandler(
-					mp_signedInfo->getAlgorithmURI());
+    // Get the SignedInfo input bytes
+    TXFMChain* chain = getSignedInfoInput();
+    Janitor<TXFMChain> j_chain(chain);
 
-	if (handler == NULL) {
+    // Check for debugging sink for the data
+    TXFMBase* sink = XSECPlatformUtils::GetReferenceLoggingSink(mp_doc);
+    if (sink)
+        chain->appendTxfm(sink);
 
+    // Setup Hash
+    // First find the appropriate handler for the URI
+    XSECAlgorithmHandler* handler =
+        XSECPlatformUtils::g_algorithmMapper->mapURIToHandler(
+                    mp_signedInfo->getAlgorithmURI());
 
-		throw XSECException(XSECException::SigVfyError,
-			"Hash method unknown in DSIGSignature::calculateSignedInfoHash()");
+    if (handler == NULL) {
+        throw XSECException(XSECException::SigVfyError,
+            "Hash method unknown in DSIGSignature::calculateSignedInfoHash()");
+    }
 
-	}
+    if (!handler->appendSignatureHashTxfm(chain, mp_signedInfo->getAlgorithmURI(), mp_signingKey)) {
+        throw XSECException(XSECException::SigVfyError,
+            "Unexpected error in handler whilst appending Signature Hash transform");
+    }
 
-	if (!handler->appendSignatureHashTxfm(chain, mp_signedInfo->getAlgorithmURI(), mp_signingKey)) {
-
-		throw XSECException(XSECException::SigVfyError,
-			"Unexpected error in handler whilst appending Signature Hash transform");
-
-	}
-
-
-	// Write hash to the buffer
-	return chain->getLastTxfm()->readBytes((XMLByte *) hashBuf, hashBufLen);
 
+    // Write hash to the buffer
+    return chain->getLastTxfm()->readBytes((XMLByte*) hashBuf, hashBufLen);
 }
 
-unsigned int DSIGSignature::calculateSignedInfoAndReferenceHash(unsigned char * hashBuf, 
-													unsigned int hashBufLen) const {
+unsigned int DSIGSignature::calculateSignedInfoAndReferenceHash(unsigned char* hashBuf,
+                                                    unsigned int hashBufLen) const {
 
-	// Set up the reference list hashes - including any manifests
-	mp_signedInfo->hash(m_interlockingReferences);
-	// calculaet signed InfoHash
-	return calculateSignedInfoHash(hashBuf,hashBufLen);
+    // Set up the reference list hashes - including any manifests
+    mp_signedInfo->hash(m_interlockingReferences);
+    // calculaet signed InfoHash
+    return calculateSignedInfoHash(hashBuf,hashBufLen);
 }
 
 // --------------------------------------------------------------------------------
 //           Verify a signature
 // --------------------------------------------------------------------------------
 
-bool DSIGSignature::verifySignatureOnlyInternal(void) const {
+bool DSIGSignature::verifySignatureOnlyInternal() const {
 
-	unsigned char hash[4096];
+    unsigned char hash[4096];
 
-	if (!m_loaded) {
+    if (!m_loaded) {
 
-		// Need to call "load" prior to checking a signature
-		throw XSECException(XSECException::SigVfyError,
-					"DSIGSignature::verify() called prior to DSIGSignature::load()");
+        // Need to call "load" prior to checking a signature
+        throw XSECException(XSECException::SigVfyError,
+                    "DSIGSignature::verify() called prior to DSIGSignature::load()");
 
-	}
+    }
 
-	// FIX: CVE-2009-0217
+    // FIX: CVE-2009-0217
 
-	if (mp_signedInfo->getHMACOutputLength() > 0 && mp_signedInfo->getHMACOutputLength() < 80) {
-	    throw XSECException(XSECException::SigVfyError,
+    if (mp_signedInfo->getHMACOutputLength() > 0 && mp_signedInfo->getHMACOutputLength() < 80) {
+        throw XSECException(XSECException::SigVfyError,
             "DSIGSignature::verify() - HMACOutputLength is unsafe");
-	}
-
-	// Try to find a key
-	if (mp_signingKey == NULL) {
+    }
 
-//		// Try to load a key from the KeyInfo list
-//		if ((mp_signingKey = m_keyInfoList.findKey()) == NULL) {
+    // Try to find a key
+    if (mp_signingKey == NULL) {
 
-//			throw XSECException(XSECException::SigVfyError,
-//				"DSIGSignature::verify() - no verification key loaded and cannot determine from KeyInfo list");
-//		}
+//        // Try to load a key from the KeyInfo list
+//        if ((mp_signingKey = m_keyInfoList.findKey()) == NULL) {
 
-		if (mp_KeyInfoResolver == NULL) {
-			
-			throw XSECException(XSECException::SigVfyError,
-				"DSIGSignature::verify() - no verification key loaded and no KeyInfoResolver loaded");
+//            throw XSECException(XSECException::SigVfyError,
+//                "DSIGSignature::verify() - no verification key loaded and cannot determine from KeyInfo list");
+//        }
 
-		}
-		
-		if ((mp_signingKey = mp_KeyInfoResolver->resolveKey(&m_keyInfoList)) == NULL) {
+        if (mp_KeyInfoResolver == NULL) {
 
-			throw XSECException(XSECException::SigVfyError,
-				"DSIGSignature::verify() - no verification key loaded and cannot determine from KeyInfoResolver");
-		}
+            throw XSECException(XSECException::SigVfyError,
+                "DSIGSignature::verify() - no verification key loaded and no KeyInfoResolver loaded");
 
-	}
+        }
 
-	// Get the SignedInfo input bytes
-	TXFMChain * chain = getSignedInfoInput();
-	Janitor<TXFMChain> j_chain(chain);
+        if ((mp_signingKey = mp_KeyInfoResolver->resolveKey(&m_keyInfoList)) == NULL) {
 
-	calculateSignedInfoHash(hash, 4096);
+            throw XSECException(XSECException::SigVfyError,
+                "DSIGSignature::verify() - no verification key loaded and cannot determine from KeyInfoResolver");
+        }
 
-	// Now set up to verify
-	// First find the appropriate handler for the URI
-	XSECAlgorithmHandler * handler = 
-		XSECPlatformUtils::g_algorithmMapper->mapURIToHandler(
-					mp_signedInfo->getAlgorithmURI());
+    }
 
-	if (handler == NULL) {
+    // Get the SignedInfo input bytes
+    TXFMChain* chain = getSignedInfoInput();
+    Janitor<TXFMChain> j_chain(chain);
 
-		throw XSECException(XSECException::SigVfyError,
-			"Hash method unknown in DSIGSignature::verifySignatureOnlyInternal()");
+    calculateSignedInfoHash(hash, 4096);
 
-	}
+    // Now set up to verify
+    // First find the appropriate handler for the URI
+    XSECAlgorithmHandler* handler =
+        XSECPlatformUtils::g_algorithmMapper->mapURIToHandler(
+                    mp_signedInfo->getAlgorithmURI());
 
-	bool sigVfyRet = handler->verifyBase64Signature(chain, 
-		mp_signedInfo->getAlgorithmURI(), 
-		m_signatureValueSB.rawCharBuffer(), 
-		mp_signedInfo->getHMACOutputLength(),
-		mp_signingKey);
+    if (handler == NULL) {
 
-	if (!sigVfyRet)
-		m_errStr.sbXMLChCat("Validation of <SignedInfo> failed");
+        throw XSECException(XSECException::SigVfyError,
+            "Hash method unknown in DSIGSignature::verifySignatureOnlyInternal()");
 
-	return sigVfyRet;
+    }
 
-}
+    bool sigVfyRet = handler->verifyBase64Signature(chain,
+        mp_signedInfo->getAlgorithmURI(),
+        m_signatureValueSB.rawCharBuffer(),
+        mp_signedInfo->getHMACOutputLength(),
+        mp_signingKey);
 
-bool DSIGSignature::verifySignatureOnly(void) const {
+    if (!sigVfyRet)
+        m_errStr.sbXMLChCat("Validation of <SignedInfo> failed");
 
-	m_errStr.sbTranscodeIn("");
-	return verifySignatureOnlyInternal();
+    return sigVfyRet;
+}
 
+bool DSIGSignature::verifySignatureOnly() const {
+    m_errStr.sbTranscodeIn("");
+    return verifySignatureOnlyInternal();
 }
 
-bool DSIGSignature::verify(void) const {
+bool DSIGSignature::verify() const {
 
-	// We have a (hopefully) fully loaded signature.  Need to 
-	// verify
+    // We have a (hopefully) fully loaded signature.  Need to
+    // verify
 
-	bool referenceCheckResult;
+    bool referenceCheckResult;
 
-	if (!m_loaded) {
+    if (!m_loaded) {
 
-		// Need to call "load" prior to checking a signature
-		throw XSECException(XSECException::SigVfyError,
-					"DSIGSignature::verify() called prior to DSIGSignature::load()");
+        // Need to call "load" prior to checking a signature
+        throw XSECException(XSECException::SigVfyError,
+                    "DSIGSignature::verify() called prior to DSIGSignature::load()");
 
-	}
+    }
 
-	// Reset
-	m_errStr.sbXMLChIn(DSIGConstants::s_unicodeStrEmpty);
+    // Reset
+    m_errStr.sbXMLChIn(DSIGConstants::s_unicodeStrEmpty);
 
-	// First thing to do is check the references
+    // First thing to do is check the references
 
-	referenceCheckResult = mp_signedInfo->verify(m_errStr);
+    referenceCheckResult = mp_signedInfo->verify(m_errStr);
 
-	// Check the signature
+    // Check the signature
 
-	bool sigVfyResult = verifySignatureOnlyInternal();
+    bool sigVfyResult = verifySignatureOnlyInternal();
 
-	return sigVfyResult & referenceCheckResult;
+    return sigVfyResult & referenceCheckResult;
 }
 
 // --------------------------------------------------------------------------------
 //           Sign the XML document that has been previously loaded
 // --------------------------------------------------------------------------------
 
-void DSIGSignature::sign(void) {
+void DSIGSignature::sign() {
+
+    // We have a (hopefully) fully loaded signature.  Need to
+    // sign
 
-	// We have a (hopefully) fully loaded signature.  Need to 
-	// sign
+    if (!m_loaded) {
 
-	if (!m_loaded) {
+        // Need to call "load" prior to checking a signature
+        throw XSECException(XSECException::SigVfyError,
+                    "DSIGSignature::sign() called prior to DSIGSignature::load()");
 
-		// Need to call "load" prior to checking a signature
-		throw XSECException(XSECException::SigVfyError,
-					"DSIGSignature::sign() called prior to DSIGSignature::load()");
+    }
 
-	}
+    // Check we have a key
+    if (mp_signingKey == NULL) {
 
-	// Check we have a key
-	if (mp_signingKey == NULL) {
+        throw XSECException(XSECException::SigVfyError,
+            "DSIGSignature::sign() - no signing key loaded");
 
-		throw XSECException(XSECException::SigVfyError,
-			"DSIGSignature::sign() - no signing key loaded");
-		
 
-	}
+    }
 
-	// Reset error string in case we have any reference problems.
-	m_errStr.sbXMLChIn(DSIGConstants::s_unicodeStrEmpty);
+    // Reset error string in case we have any reference problems.
+    m_errStr.sbXMLChIn(DSIGConstants::s_unicodeStrEmpty);
 
-	// Set up the reference list hashes - including any manifests
-	mp_signedInfo->hash(m_interlockingReferences);
+    // Set up the reference list hashes - including any manifests
+    mp_signedInfo->hash(m_interlockingReferences);
 
-	// Get the SignedInfo input bytes
-	TXFMChain * chain = getSignedInfoInput();
-	Janitor<TXFMChain> j_chain(chain);
+    // Get the SignedInfo input bytes
+    TXFMChain* chain = getSignedInfoInput();
+    Janitor<TXFMChain> j_chain(chain);
 
-	// Calculate the hash to be signed
+    // Calculate the hash to be signed
 
-	safeBuffer b64Buf;
+    safeBuffer b64Buf;
 
-	XSECAlgorithmHandler * handler = 
-		XSECPlatformUtils::g_algorithmMapper->mapURIToHandler(
-					mp_signedInfo->getAlgorithmURI());
+    XSECAlgorithmHandler* handler =
+        XSECPlatformUtils::g_algorithmMapper->mapURIToHandler(
+                    mp_signedInfo->getAlgorithmURI());
 
-	if (handler == NULL) {
+    if (handler == NULL) {
 
 
-		throw XSECException(XSECException::SigVfyError,
-			"Hash method unknown in DSIGSignature::sign()");
+        throw XSECException(XSECException::SigVfyError,
+            "Hash method unknown in DSIGSignature::sign()");
 
-	}
+    }
 
-	if (!handler->signToSafeBuffer(chain, mp_signedInfo->getAlgorithmURI(), 
-								   mp_signingKey, mp_signedInfo->getHMACOutputLength(), b64Buf)) {
+    if (!handler->signToSafeBuffer(chain, mp_signedInfo->getAlgorithmURI(),
+                                   mp_signingKey, mp_signedInfo->getHMACOutputLength(), b64Buf)) {
 
-		throw XSECException(XSECException::SigVfyError,
-			"Unexpected error in handler whilst appending Signature Hash transform");
+        throw XSECException(XSECException::SigVfyError,
+            "Unexpected error in handler whilst appending Signature Hash transform");
 
-	}
+    }
 
-	// Now we have the signature - place it in the DOM structures
+    // Now we have the signature - place it in the DOM structures
 
-	DOMNode *tmpElt = mp_signatureValueNode->getFirstChild();
+    DOMNode*tmpElt = mp_signatureValueNode->getFirstChild();
 
-	while (tmpElt != NULL && tmpElt->getNodeType() != DOMNode::TEXT_NODE)
-		tmpElt = tmpElt->getNextSibling();
+    while (tmpElt != NULL && tmpElt->getNodeType() != DOMNode::TEXT_NODE)
+        tmpElt = tmpElt->getNextSibling();
 
-	if (tmpElt == NULL) {
-		// Need to create the underlying TEXT_NODE
-		DOMDocument * doc = mp_signatureValueNode->getOwnerDocument();
-		tmpElt = doc->createTextNode(b64Buf.sbStrToXMLCh());
-		mp_signatureValueNode->appendChild(tmpElt);
-	}
-	else {
-		tmpElt->setNodeValue(b64Buf.sbStrToXMLCh());
-	}
+    if (tmpElt == NULL) {
+        // Need to create the underlying TEXT_NODE
+        DOMDocument* doc = mp_signatureValueNode->getOwnerDocument();
+        tmpElt = doc->createTextNode(b64Buf.sbStrToXMLCh());
+        mp_signatureValueNode->appendChild(tmpElt);
+    }
+    else {
+        tmpElt->setNodeValue(b64Buf.sbStrToXMLCh());
+    }
 
-	// And copy to the local buffer
-	m_signatureValueSB = b64Buf;
-	
+    // And copy to the local buffer
+    m_signatureValueSB = b64Buf;
 }
 
 // --------------------------------------------------------------------------------
 //           Key Management
 // --------------------------------------------------------------------------------
 
-void DSIGSignature::setSigningKey(XSECCryptoKey *k) {
-
-	if (mp_signingKey != NULL)
-		delete mp_signingKey;
+void DSIGSignature::setSigningKey(XSECCryptoKey* k) {
 
-	mp_signingKey = k;
+    if (mp_signingKey != NULL)
+        delete mp_signingKey;
 
+    mp_signingKey = k;
 }
 
 // --------------------------------------------------------------------------------
@@ -1070,52 +974,38 @@ void DSIGSignature::setSigningKey(XSECCr
  */
 
 void DSIGSignature::setIdByAttributeName(bool flag) {
-
-	mp_env->setIdByAttributeName(flag);
-
+    mp_env->setIdByAttributeName(flag);
 }
 
-bool DSIGSignature::getIdByAttributeName(void) const {
-
-	return mp_env->getIdByAttributeName();
-
+bool DSIGSignature::getIdByAttributeName() const {
+    return mp_env->getIdByAttributeName();
 }
 
 
-void DSIGSignature::registerIdAttributeName(const XMLCh * name) {
-
-	mp_env->registerIdAttributeName(name);
-
+void DSIGSignature::registerIdAttributeName(const XMLCh* name) {
+    mp_env->registerIdAttributeName(name);
 }
 
-bool DSIGSignature::deregisterIdAttributeName(const XMLCh * name) {
-
-	return mp_env->deregisterIdAttributeName(name);
-
+bool DSIGSignature::deregisterIdAttributeName(const XMLCh* name) {
+    return mp_env->deregisterIdAttributeName(name);
 }
 
-void DSIGSignature::registerIdAttributeNameNS(const XMLCh * ns, const XMLCh * name) {
-
-	mp_env->registerIdAttributeNameNS(ns, name);
-
+void DSIGSignature::registerIdAttributeNameNS(const XMLCh* ns, const XMLCh* name) {
+    mp_env->registerIdAttributeNameNS(ns, name);
 }
 
-bool DSIGSignature::deregisterIdAttributeNameNS(const XMLCh * ns, const XMLCh * name) {
-
-	return mp_env->deregisterIdAttributeNameNS(ns, name);
-
+bool DSIGSignature::deregisterIdAttributeNameNS(const XMLCh* ns, const XMLCh* name) {
+    return mp_env->deregisterIdAttributeNameNS(ns, name);
 }
 
 // --------------------------------------------------------------------------------
 //           Other functions
 // --------------------------------------------------------------------------------
 
-const XMLCh * DSIGSignature::getSignatureValue(void) const {
+const XMLCh* DSIGSignature::getSignatureValue() const {
 
-	if (mp_signatureValueNode == NULL)
-		return NULL;
-
-	return findFirstChildOfType(mp_signatureValueNode, DOMNode::TEXT_NODE)->getNodeValue();
+    if (mp_signatureValueNode == NULL)
+        return NULL;
 
+    return findFirstChildOfType(mp_signatureValueNode, DOMNode::TEXT_NODE)->getNodeValue();
 }
-