eu.europa.esig.dss.DSSXMLUtils.java Source code

Java tutorial

Introduction

Here is the source code for eu.europa.esig.dss.DSSXMLUtils.java

Source

/**
 * DSS - Digital Signature Services
 * Copyright (C) 2015 European Commission, provided under the CEF programme
 *
 * This file is part of the "DSS - Digital Signature Services" project.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
package eu.europa.esig.dss;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.xml.XMLConstants;
import javax.xml.crypto.dsig.XMLSignature;
import javax.xml.crypto.dsig.dom.DOMValidateContext;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.xml.security.Init;
import org.apache.xml.security.c14n.Canonicalizer;
import org.apache.xml.security.transforms.Transforms;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.w3c.dom.bootstrap.DOMImplementationRegistry;
import org.w3c.dom.ls.DOMImplementationLS;
import org.w3c.dom.ls.LSOutput;
import org.w3c.dom.ls.LSSerializer;
import org.xml.sax.SAXException;

/**
 * Utility class that contains some XML related method.
 *
 */
public final class DSSXMLUtils {

    private static final Logger LOG = LoggerFactory.getLogger(DSSXMLUtils.class);

    public static final String ID_ATTRIBUTE_NAME = "id";
    public static final String XAD_ESV141_XSD = "/XAdESv141.xsd";

    private static DocumentBuilderFactory dbFactory;

    private static final XPathFactory factory = XPathFactory.newInstance();

    private static NamespaceContextMap namespacePrefixMapper;

    private static final Map<String, String> namespaces;

    private static final Set<String> transforms;

    private static final Set<String> canonicalizers;

    static {

        Init.init();

        namespacePrefixMapper = new NamespaceContextMap();
        namespaces = new HashMap<String, String>();
        registerDefaultNamespaces();

        transforms = new HashSet<String>();
        registerDefaultTransforms();

        canonicalizers = new HashSet<String>();
        registerDefaultCanonicalizers();
    }

    private static Schema schema = null;

    /**
     * This method registers the default namespaces.
     */
    private static void registerDefaultNamespaces() {

        registerNamespace("ds", XMLSignature.XMLNS);
        registerNamespace("dsig", XMLSignature.XMLNS);
        registerNamespace("xades", XAdESNamespaces.XAdES); // 1.3.2
        registerNamespace("xades141", XAdESNamespaces.XAdES141);
        registerNamespace("xades122", XAdESNamespaces.XAdES122);
        registerNamespace("xades111", XAdESNamespaces.XAdES111);
        registerNamespace("asic", ASiCNamespaces.ASiC);
    }

    /**
     * This method registers the default transforms.
     */
    private static void registerDefaultTransforms() {

        registerTransform(Transforms.TRANSFORM_BASE64_DECODE);
        registerTransform(Transforms.TRANSFORM_ENVELOPED_SIGNATURE);
        registerTransform(Transforms.TRANSFORM_XPATH);
        registerTransform(Transforms.TRANSFORM_XPATH2FILTER);
        registerTransform(Transforms.TRANSFORM_XPOINTER);
        registerTransform(Transforms.TRANSFORM_XSLT);
    }

    /**
     * This method registers the default canonicalizers.
     */
    private static void registerDefaultCanonicalizers() {

        registerCanonicalizer(Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS);
        registerCanonicalizer(Canonicalizer.ALGO_ID_C14N_EXCL_OMIT_COMMENTS);
        registerCanonicalizer(Canonicalizer.ALGO_ID_C14N11_OMIT_COMMENTS);
        registerCanonicalizer(Canonicalizer.ALGO_ID_C14N_PHYSICAL);
        registerCanonicalizer(Canonicalizer.ALGO_ID_C14N_WITH_COMMENTS);
        registerCanonicalizer(Canonicalizer.ALGO_ID_C14N_EXCL_WITH_COMMENTS);
        registerCanonicalizer(Canonicalizer.ALGO_ID_C14N11_WITH_COMMENTS);
    }

    /**
     * This class is an utility class and cannot be instantiated.
     */
    private DSSXMLUtils() {
    }

    /**
     * This method allows to register a namespace and associated prefix. If the prefix exists already it is replaced.
     *
     * @param prefix    namespace prefix
     * @param namespace namespace
     * @return true if this map did not already contain the specified element
     */
    public static boolean registerNamespace(final String prefix, final String namespace) {

        final String put = namespaces.put(prefix, namespace);
        namespacePrefixMapper.registerNamespace(prefix, namespace);
        return put == null;
    }

    /**
     * This method allows to register a transformation.
     *
     * @param transformURI the URI of transform
     * @return true if this set did not already contain the specified element
     */
    public static boolean registerTransform(final String transformURI) {

        final boolean added = transforms.add(transformURI);
        return added;
    }

    /**
     * This method allows to register a canonicalizer.
     *
     * @param c14nAlgorithmURI the URI of canonicalization algorithm
     * @return true if this set did not already contain the specified element
     */
    public static boolean registerCanonicalizer(final String c14nAlgorithmURI) {

        final boolean added = canonicalizers.add(c14nAlgorithmURI);
        return added;
    }

    /**
     * @param xpathString XPath query string
     * @return
     */
    private static XPathExpression createXPathExpression(final String xpathString) {

        /* XPath */
        final XPath xpath = factory.newXPath();
        xpath.setNamespaceContext(namespacePrefixMapper);
        try {
            final XPathExpression expr = xpath.compile(xpathString);
            return expr;
        } catch (XPathExpressionException ex) {
            throw new DSSException(ex);
        }
    }

    /**
     * Return the Element corresponding to the XPath query.
     *
     * @param xmlNode     The node where the search should be performed.
     * @param xPathString XPath query string
     * @return
     */
    public static Element getElement(final Node xmlNode, final String xPathString) {

        return (Element) getNode(xmlNode, xPathString);
    }

    /**
     * Return the Node corresponding to the XPath query.
     *
     * @param xmlNode     The node where the search should be performed.
     * @param xPathString XPath query string
     * @return
     */
    public static Node getNode(final Node xmlNode, final String xPathString) {

        final NodeList list = getNodeList(xmlNode, xPathString);
        if (list.getLength() > 1) {
            throw new DSSException("More than one result for XPath: " + xPathString);
        }
        return list.item(0);
    }

    /**
     * This method returns the list of children's names for a given {@code Node}.
     *
     * @param xmlNode     The node where the search should be performed.
     * @param xPathString XPath query string
     * @return {@code List} of children's names
     */
    public static List<String> getChildrenNames(final Node xmlNode, final String xPathString) {

        ArrayList<String> childrenNames = new ArrayList<String>();

        final Element element = DSSXMLUtils.getElement(xmlNode, xPathString);
        if (element != null) {

            final NodeList unsignedProperties = element.getChildNodes();
            for (int ii = 0; ii < unsignedProperties.getLength(); ++ii) {

                final Node node = unsignedProperties.item(ii);
                childrenNames.add(node.getLocalName());
            }
        }
        return childrenNames;
    }

    /**
     * Returns the NodeList corresponding to the XPath query.
     *
     * @param xmlNode     The node where the search should be performed.
     * @param xPathString XPath query string
     * @return
     * @throws XPathExpressionException
     */
    public static NodeList getNodeList(final Node xmlNode, final String xPathString) {

        try {

            final XPathExpression expr = createXPathExpression(xPathString);
            final NodeList evaluated = (NodeList) expr.evaluate(xmlNode, XPathConstants.NODESET);
            return evaluated;
        } catch (XPathExpressionException e) {
            throw new DSSException(e);
        }
    }

    /**
     * Returns the String value of the corresponding to the XPath query.
     *
     * @param xmlNode     The node where the search should be performed.
     * @param xPathString XPath query string
     * @return string value of the XPath query
     * @throws XPathExpressionException
     */
    public static String getValue(final Node xmlNode, final String xPathString) {

        try {

            final XPathExpression xPathExpression = createXPathExpression(xPathString);
            final String string = (String) xPathExpression.evaluate(xmlNode, XPathConstants.STRING);
            return string.trim();
        } catch (XPathExpressionException e) {
            throw new DSSException(e);
        }
    }

    /**
     * Returns the number of found elements based on the XPath query.
     *
     * @param xmlNode
     * @param xPathString
     * @return
     */
    public static int count(final Node xmlNode, final String xPathString) {
        try {
            final XPathExpression xPathExpression = createXPathExpression(xPathString);
            final Double number = (Double) xPathExpression.evaluate(xmlNode, XPathConstants.NUMBER);
            return number.intValue();
        } catch (XPathExpressionException e) {
            throw new DSSException(e);
        }
    }

    /**
     * Returns true if the xpath query contains something
     *
     * @param xmlNode
     * @param xPathString
     * @return
     */
    public static boolean isNotEmpty(final Node xmlNode, final String xPathString) {
        // xpath suffix allows to skip text nodes and empty lines
        NodeList nodeList = getNodeList(xmlNode, xPathString + "/child::node()[not(self::text())]");
        if ((nodeList != null) && (nodeList.getLength() > 0)) {
            return true;
        }
        return false;
    }

    /**
     * Document Object Model (DOM) Level 3 Load and Save Specification See: http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/
     *
     * @param xmlNode The node to be serialized.
     * @return
     */
    public static byte[] serializeNode(final Node xmlNode) {

        try {

            final DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance();
            final DOMImplementationLS impl = (DOMImplementationLS) registry.getDOMImplementation("LS");
            final LSSerializer writer = impl.createLSSerializer();

            final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            final LSOutput output = impl.createLSOutput();
            output.setByteStream(buffer);
            writer.write(xmlNode, output);

            final byte[] bytes = buffer.toByteArray();
            return bytes;
        } catch (Exception e) {
            throw new DSSException(e);
        }
    }

    /**
     * An ID attribute can only be dereferenced if it is declared in the validation context. This behaviour is caused by the fact that the attribute does not have attached type of
     * information. Another solution is to parse the XML against some DTD or XML schema. This process adds the necessary type of information to each ID attribute.
     * This method is useful to carry out tests with different signature provider.
     *
     * @param context
     * @param element
     */
    public static void recursiveIdBrowse(final DOMValidateContext context, final Element element) {

        for (int ii = 0; ii < element.getChildNodes().getLength(); ii++) {

            final Node node = element.getChildNodes().item(ii);
            if (node.getNodeType() == Node.ELEMENT_NODE) {

                final Element childElement = (Element) node;
                setIDIdentifier(context, childElement);
                recursiveIdBrowse(context, childElement);
            }
        }
    }

    /**
     * An ID attribute can only be dereferenced if it is declared in the validation context. This behaviour is caused by the fact that the attribute does not have attached type of
     * information. Another solution is to parse the XML against some DTD or XML schema. This process adds the necessary type of information to each ID attribute.
     *
     * @param element
     */
    public static void recursiveIdBrowse(final Element element) {

        for (int ii = 0; ii < element.getChildNodes().getLength(); ii++) {

            final Node node = element.getChildNodes().item(ii);
            if (node.getNodeType() == Node.ELEMENT_NODE) {

                final Element childElement = (Element) node;
                setIDIdentifier(childElement);
                recursiveIdBrowse(childElement);
            }
        }
    }

    /**
     * If this method finds an attribute with names ID (case-insensitive) then it is returned. If there is more than one ID attributes then the first one is returned.
     *
     * @param element to be checked
     * @return the ID attribute value or null
     */
    public static String getIDIdentifier(final Element element) {

        final NamedNodeMap attributes = element.getAttributes();
        for (int jj = 0; jj < attributes.getLength(); jj++) {

            final Node item = attributes.item(jj);
            final String localName = item.getNodeName();
            if (localName != null) {
                final String id = localName.toLowerCase();
                if (ID_ATTRIBUTE_NAME.equals(id)) {

                    return item.getTextContent();
                }
            }
        }
        return null;
    }

    /**
     * If this method finds an attribute with names ID (case-insensitive) then declares it to be a user-determined ID attribute.
     *
     * @param childElement
     */
    public static void setIDIdentifier(final DOMValidateContext context, final Element childElement) {

        final NamedNodeMap attributes = childElement.getAttributes();
        for (int jj = 0; jj < attributes.getLength(); jj++) {

            final Node item = attributes.item(jj);
            final String localName = item.getNodeName();
            if (localName != null) {
                final String id = localName.toLowerCase();
                if (ID_ATTRIBUTE_NAME.equals(id)) {

                    context.setIdAttributeNS(childElement, null, localName);
                    break;
                }
            }
        }
    }

    /**
     * If this method finds an attribute with names ID (case-insensitive) then declares it to be a user-determined ID attribute.
     *
     * @param childElement
     */
    public static void setIDIdentifier(final Element childElement) {

        final NamedNodeMap attributes = childElement.getAttributes();
        for (int jj = 0; jj < attributes.getLength(); jj++) {

            final Node item = attributes.item(jj);
            final String localName = item.getNodeName();
            if (localName != null) {
                final String id = localName.toLowerCase();
                if (ID_ATTRIBUTE_NAME.equals(id)) {

                    childElement.setIdAttribute(localName, true);
                    break;
                }
            }
        }
    }

    /**
     * Guarantees that the xmlString builder has been created.
     *
     * @throws ParserConfigurationException
     */
    private static void ensureDocumentBuilder() throws DSSException {

        if (dbFactory != null) {
            return;
        }
        dbFactory = DocumentBuilderFactory.newInstance();
        dbFactory.setNamespaceAware(true);
        try {
            // disable external entities
            dbFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
            dbFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
            dbFactory.setXIncludeAware(false);
            dbFactory.setExpandEntityReferences(false);
        } catch (ParserConfigurationException e) {
            throw new DSSException(e);
        }
    }

    public static TransformerFactory getSecureTransformerFactory() {
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        try {
            transformerFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
        } catch (TransformerConfigurationException e) {
            throw new DSSException(e);
        }
        return transformerFactory;
    }

    /**
     * Creates the new empty Document.
     *
     * @return
     * @throws ParserConfigurationException
     * @throws IOException
     * @throws SAXException
     */
    public static Document buildDOM() {

        ensureDocumentBuilder();

        try {
            return dbFactory.newDocumentBuilder().newDocument();
        } catch (ParserConfigurationException e) {
            throw new DSSException(e);
        }
    }

    /**
     * This method returns the {@link org.w3c.dom.Document} created based on the XML string.
     *
     * @param xmlString The string representing the dssDocument to be created.
     * @return
     * @throws ParserConfigurationException
     * @throws IOException
     * @throws SAXException
     */
    public static Document buildDOM(final String xmlString) throws DSSException {

        final InputStream input = new ByteArrayInputStream(DSSUtils.getUtf8Bytes(xmlString));
        return buildDOM(input);
    }

    /**
     * This method returns the {@link org.w3c.dom.Document} created based on byte array.
     *
     * @param bytes The bytes array representing the dssDocument to be created.
     * @return
     * @throws ParserConfigurationException
     * @throws IOException
     * @throws SAXException
     */
    public static Document buildDOM(final byte[] bytes) throws DSSException {

        final InputStream input = new ByteArrayInputStream(bytes);
        return buildDOM(input);
    }

    /**
     * This method returns the {@link org.w3c.dom.Document} created based on the XML inputStream.
     *
     * @param inputStream The inputStream stream representing the dssDocument to be created.
     * @return
     * @throws DSSException
     */
    public static Document buildDOM(final InputStream inputStream) throws DSSException {
        try {
            ensureDocumentBuilder();
            final Document rootElement = dbFactory.newDocumentBuilder().parse(inputStream);
            return rootElement;
        } catch (Exception e) {
            throw new DSSException(e);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }
    }

    /**
     * This method returns the {@link org.w3c.dom.Document} created based on the {@link eu.europa.esig.dss.DSSDocument}.
     *
     * @param dssDocument The DSS representation of the document from which the dssDocument is created.
     * @return
     * @throws DSSException
     */
    public static Document buildDOM(final DSSDocument dssDocument) throws DSSException {
        final InputStream input = dssDocument.openStream();
        try {
            final Document doc = buildDOM(input);
            return doc;
        } finally {
            IOUtils.closeQuietly(input);
        }
    }

    /**
     * This method says if the framework can canonicalize an XML data with the provided method.
     *
     * @param canonicalizationMethod the canonicalization method to be checked
     * @return true if it is possible to canonicalize false otherwise
     */
    public static boolean canCanonicalize(final String canonicalizationMethod) {

        if (transforms.contains(canonicalizationMethod)) {
            return false;
        }
        final boolean contains = canonicalizers.contains(canonicalizationMethod);
        return contains;
    }

    /**
     * This method canonicalizes the given array of bytes using the {@code canonicalizationMethod} parameter.
     *
     * @param canonicalizationMethod canonicalization method
     * @param toCanonicalizeBytes    array of bytes to canonicalize
     * @return array of canonicalized bytes
     * @throws DSSException if any error is encountered
     */
    public static byte[] canonicalize(final String canonicalizationMethod, final byte[] toCanonicalizeBytes)
            throws DSSException {
        try {
            final Canonicalizer c14n = Canonicalizer.getInstance(canonicalizationMethod);
            return c14n.canonicalize(toCanonicalizeBytes);
        } catch (Exception e) {
            throw new DSSException(e);
        }
    }

    /**
     * This method canonicalizes the given {@code Node}.
     *
     * @param canonicalizationMethod canonicalization method
     * @param node                   {@code Node} to canonicalize
     * @return array of canonicalized bytes
     */
    public static byte[] canonicalizeSubtree(final String canonicalizationMethod, final Node node) {
        try {
            final Canonicalizer c14n = Canonicalizer.getInstance(canonicalizationMethod);
            final byte[] canonicalized = c14n.canonicalizeSubtree(node);
            return canonicalized;
        } catch (Exception e) {
            throw new DSSException(e);
        }
    }

    /**
     * This method canonicalizes the given {@code NodeList}.
     *
     * @param canonicalizationMethod canonicalization method
     * @param nodeList               {@code NodeList} to canonicalize
     * @return array of canonicalized bytes
     */
    public static byte[] canonicalizeXPathNodeSet(final String canonicalizationMethod, final Set<Node> nodeList) {
        try {
            final Canonicalizer c14n = Canonicalizer.getInstance(canonicalizationMethod);
            final byte[] canonicalized = c14n.canonicalizeXPathNodeSet(nodeList);
            return canonicalized;
        } catch (Exception e) {
            throw new DSSException(e);
        }
    }

    /**
     * This method creates and adds a new XML {@code Element} with text value
     *
     * @param document  root document
     * @param parentDom parent node
     * @param namespace namespace
     * @param name      element name
     * @param value     element text node value
     * @return added element
     */
    public static Element addTextElement(final Document document, final Element parentDom, final String namespace,
            final String name, final String value) {

        final Element dom = document.createElementNS(namespace, name);
        parentDom.appendChild(dom);
        final Text valueNode = document.createTextNode(value);
        dom.appendChild(valueNode);
        return dom;
    }

    /**
     * This method creates and adds a new XML {@code Element}
     *
     * @param document  root document
     * @param parentDom parent node
     * @param namespace namespace
     * @param name      element name
     * @return added element
     */
    public static Element addElement(final Document document, final Element parentDom, final String namespace,
            final String name) {

        final Element dom = document.createElementNS(namespace, name);
        parentDom.appendChild(dom);
        return dom;
    }

    public static byte[] transformDomToByteArray(final Document documentDom) {

        try {

            final TransformerFactory transformerFactory = TransformerFactory.newInstance();
            final Transformer transformer = transformerFactory.newTransformer();
            final String xmlEncoding = documentDom.getXmlEncoding();
            if (StringUtils.isNotBlank(xmlEncoding)) {
                transformer.setOutputProperty(OutputKeys.ENCODING, xmlEncoding);
            }
            final DOMSource source = new DOMSource(documentDom);

            final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            final StreamResult streamResult = new StreamResult(byteArrayOutputStream);
            transformer.transform(source, streamResult);
            byte[] byteArray = byteArrayOutputStream.toByteArray();
            return byteArray;
        } catch (final TransformerException e) {
            throw new DSSException(e);
        }
    }

    /**
     * This method sets a text node to the given DOM element.
     *
     * @param document  root document
     * @param parentDom parent node
     * @param text      text to be added
     */
    public static void setTextNode(final Document document, final Element parentDom, final String text) {

        final Text textNode = document.createTextNode(text);
        parentDom.appendChild(textNode);
    }

    /**
     * Creates a DOM Document object of the specified type with its document element.
     *
     * @param namespaceURI  the namespace URI of the document element to create or null
     * @param qualifiedName the qualified name of the document element to be created or null
     * @param element       document {@code Element}
     * @return {@code Document}
     */
    public static Document createDocument(final String namespaceURI, final String qualifiedName,
            final Element element) {
        ensureDocumentBuilder();

        DOMImplementation domImpl;
        try {
            domImpl = dbFactory.newDocumentBuilder().getDOMImplementation();
        } catch (ParserConfigurationException e) {
            throw new DSSException(e);
        }
        final Document newDocument = domImpl.createDocument(namespaceURI, qualifiedName, null);
        final Element newElement = newDocument.getDocumentElement();
        newDocument.adoptNode(element);
        newElement.appendChild(element);

        return newDocument;
    }

    /**
     * Creates a DOM document without document element.
     *
     * @param namespaceURI  the namespace URI of the document element to create or null
     * @param qualifiedName the qualified name of the document element to be created or null
     * @return {@code Document}
     */
    public static Document createDocument(final String namespaceURI, final String qualifiedName) {
        ensureDocumentBuilder();

        DOMImplementation domImpl;
        try {
            domImpl = dbFactory.newDocumentBuilder().getDOMImplementation();
        } catch (ParserConfigurationException e) {
            throw new DSSException(e);
        }

        return domImpl.createDocument(namespaceURI, qualifiedName, null);
    }

    /**
     * Creates a DOM Document object of the specified type with its document elements.
     *
     * @param namespaceURI
     * @param qualifiedName
     * @param element1
     * @param element2
     * @return {@code Document}
     */
    public static Document createDocument(final String namespaceURI, final String qualifiedName,
            final Element element1, final Element element2) {
        ensureDocumentBuilder();

        DOMImplementation domImpl;
        try {
            domImpl = dbFactory.newDocumentBuilder().getDOMImplementation();
        } catch (ParserConfigurationException e) {
            throw new DSSException(e);
        }
        final Document newDocument = domImpl.createDocument(namespaceURI, qualifiedName, null);
        final Element newElement = newDocument.getDocumentElement();
        newDocument.adoptNode(element1);
        newElement.appendChild(element1);

        newDocument.adoptNode(element2);
        newElement.appendChild(element2);

        return newDocument;
    }

    /**
     * Converts a given {@code Date} to a new {@code XMLGregorianCalendar}.
     *
     * @param date the date to be converted
     * @return the new {@code XMLGregorianCalendar} or null
     */
    public static XMLGregorianCalendar createXMLGregorianCalendar(final Date date) {

        if (date == null) {
            return null;
        }
        final GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        try {

            XMLGregorianCalendar xmlGregorianCalendar = DatatypeFactory.newInstance()
                    .newXMLGregorianCalendar(calendar);
            xmlGregorianCalendar.setFractionalSecond(null);
            xmlGregorianCalendar = xmlGregorianCalendar.normalize(); // to UTC = Zulu
            return xmlGregorianCalendar;
        } catch (DatatypeConfigurationException e) {
            LOG.warn("Unable to properly convert a Date to an XMLGregorianCalendar " + e.getMessage(), e);
        }
        return null;
    }

    /**
     * This method allows to convert the given text (XML representation of a date) to the {@code Date}.
     *
     * @param text the text representing the XML date
     * @return {@code Date} converted or null
     */
    public static Date getDate(final String text) {

        try {

            final DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
            final XMLGregorianCalendar xmlGregorianCalendar = datatypeFactory.newXMLGregorianCalendar(text);
            return xmlGregorianCalendar.toGregorianCalendar().getTime();
        } catch (DatatypeConfigurationException e) {
            // do nothing
        }
        return null;
    }

    /**
     * This method retrieves an element based on its ID
     *
     * @param currentDom the DOM in which the element has to be retrieved
     * @param elementId  the specified ID
     * @param namespace  the namespace to take into account
     * @param tagName    the tagName of the element to find
     * @return the
     * @throws NullPointerException
     */
    public static Element getElementById(Document currentDom, String elementId, String namespace, String tagName)
            throws NullPointerException {

        Element element = null;
        NodeList nodes = currentDom.getElementsByTagNameNS(namespace, tagName);

        for (int i = 0; i < nodes.getLength(); i++) {
            element = (Element) nodes.item(i);
            if (elementId.equals(DSSXMLUtils.getIDIdentifier(element))) {
                return element;
            }
        }
        if (element == null) {
            throw new NullPointerException();
        }
        return null;
    }

    /**
     * This method allows to validate an XML against the XAdES XSD schema.
     *
     * @param streamSource {@code InputStream} XML to validate
     * @return null if the XSD validates the XML, error message otherwise
     */
    public static String validateAgainstXSD(final StreamSource streamSource) {

        try {

            if (schema == null) {
                schema = getSchema();
            }
            final Validator validator = schema.newValidator();
            validator.validate(streamSource);
            return StringUtils.EMPTY;
        } catch (Exception e) {
            LOG.warn("Error during the XML schema validation!", e);
            return e.getMessage();
        }
    }

    private static Schema getSchema() throws SAXException {

        final ResourceLoader resourceLoader = new ResourceLoader();
        final InputStream xadesXsd = resourceLoader.getResource(XAD_ESV141_XSD);
        final SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        return factory.newSchema(new StreamSource(xadesXsd));
    }

    /**
     * This method allows to convert an XML {@code Node} to a {@code String}.
     *
     * @param node {@code Node} to be converted
     * @return {@code String} representation of the node
     */
    public static String xmlToString(final Node node) {
        try {
            final Source source = new DOMSource(node);
            final StringWriter stringWriter = new StringWriter();
            final Result result = new StreamResult(stringWriter);
            final TransformerFactory factory = TransformerFactory.newInstance();
            final Transformer transformer = factory.newTransformer();
            transformer.transform(source, result);
            return stringWriter.getBuffer().toString();
        } catch (Exception e) {
            throw new DSSException(e);
        }
    }
}