org.apache.xml.security.transforms.implementations.TransformXPath2Filter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of xmlsec Show documentation
Show all versions of xmlsec Show documentation
Apache XML Security for Java supports XML-Signature Syntax and Processing,
W3C Recommendation 12 February 2002, and XML Encryption Syntax and
Processing, W3C Recommendation 10 December 2002. As of version 1.4,
the library supports the standard Java API JSR-105: XML Digital Signature APIs.
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.xml.security.transforms.implementations;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;
import org.apache.xml.security.c14n.CanonicalizationException;
import org.apache.xml.security.c14n.InvalidCanonicalizerException;
import org.apache.xml.security.exceptions.XMLSecurityException;
import org.apache.xml.security.signature.NodeFilter;
import org.apache.xml.security.signature.XMLSignatureInput;
import org.apache.xml.security.transforms.Transform;
import org.apache.xml.security.transforms.TransformSpi;
import org.apache.xml.security.transforms.TransformationException;
import org.apache.xml.security.transforms.Transforms;
import org.apache.xml.security.transforms.params.XPath2FilterContainer;
import org.apache.xml.security.utils.XMLUtils;
import org.apache.xml.security.utils.XPathAPI;
import org.apache.xml.security.utils.XPathFactory;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
* Implements the XML Signature XPath Filter v2.0
*
* @see XPath Filter v2.0 (TR)
*/
public class TransformXPath2Filter extends TransformSpi {
/** Field implementedTransformURI */
public static final String implementedTransformURI =
Transforms.TRANSFORM_XPATH2FILTER;
/**
* Method engineGetURI
*
* @inheritDoc
*/
protected String engineGetURI() {
return implementedTransformURI;
}
/**
* Method enginePerformTransform
* @inheritDoc
* @param input
*
* @throws TransformationException
*/
protected XMLSignatureInput enginePerformTransform(
XMLSignatureInput input, OutputStream os, Transform transformObject
) throws TransformationException {
try {
List unionNodes = new ArrayList();
List subtractNodes = new ArrayList();
List intersectNodes = new ArrayList();
Element[] xpathElements =
XMLUtils.selectNodes(
transformObject.getElement().getFirstChild(),
XPath2FilterContainer.XPathFilter2NS,
XPath2FilterContainer._TAG_XPATH2
);
if (xpathElements.length == 0) {
Object exArgs[] = { Transforms.TRANSFORM_XPATH2FILTER, "XPath" };
throw new TransformationException("xml.WrongContent", exArgs);
}
Document inputDoc = null;
if (input.getSubNode() != null) {
inputDoc = XMLUtils.getOwnerDocument(input.getSubNode());
} else {
inputDoc = XMLUtils.getOwnerDocument(input.getNodeSet());
}
for (int i = 0; i < xpathElements.length; i++) {
Element xpathElement = xpathElements[i];
XPath2FilterContainer xpathContainer =
XPath2FilterContainer.newInstance(xpathElement, input.getSourceURI());
String str =
XMLUtils.getStrFromNode(xpathContainer.getXPathFilterTextNode());
XPathFactory xpathFactory = XPathFactory.newInstance();
XPathAPI xpathAPIInstance = xpathFactory.newXPathAPI();
NodeList subtreeRoots =
xpathAPIInstance.selectNodeList(
inputDoc,
xpathContainer.getXPathFilterTextNode(),
str,
xpathContainer.getElement());
if (xpathContainer.isIntersect()) {
intersectNodes.add(subtreeRoots);
} else if (xpathContainer.isSubtract()) {
subtractNodes.add(subtreeRoots);
} else if (xpathContainer.isUnion()) {
unionNodes.add(subtreeRoots);
}
}
input.addNodeFilter(
new XPath2NodeFilter(unionNodes, subtractNodes, intersectNodes)
);
input.setNodeSet(true);
return input;
} catch (TransformerException ex) {
throw new TransformationException(ex);
} catch (DOMException ex) {
throw new TransformationException(ex);
} catch (CanonicalizationException ex) {
throw new TransformationException(ex);
} catch (InvalidCanonicalizerException ex) {
throw new TransformationException(ex);
} catch (XMLSecurityException ex) {
throw new TransformationException(ex);
} catch (SAXException ex) {
throw new TransformationException(ex);
} catch (IOException ex) {
throw new TransformationException(ex);
} catch (ParserConfigurationException ex) {
throw new TransformationException(ex);
}
}
}
class XPath2NodeFilter implements NodeFilter {
boolean hasUnionFilter;
boolean hasSubtractFilter;
boolean hasIntersectFilter;
Set unionNodes;
Set subtractNodes;
Set intersectNodes;
int inSubtract = -1;
int inIntersect = -1;
int inUnion = -1;
XPath2NodeFilter(List unionNodes, List subtractNodes,
List intersectNodes) {
hasUnionFilter = !unionNodes.isEmpty();
this.unionNodes = convertNodeListToSet(unionNodes);
hasSubtractFilter = !subtractNodes.isEmpty();
this.subtractNodes = convertNodeListToSet(subtractNodes);
hasIntersectFilter = !intersectNodes.isEmpty();
this.intersectNodes = convertNodeListToSet(intersectNodes);
}
/**
* @see org.apache.xml.security.signature.NodeFilter#isNodeInclude(org.w3c.dom.Node)
*/
public int isNodeInclude(Node currentNode) {
int result = 1;
if (hasSubtractFilter && rooted(currentNode, subtractNodes)) {
result = -1;
} else if (hasIntersectFilter && !rooted(currentNode, intersectNodes)) {
result = 0;
}
//TODO OPTIMIZE
if (result == 1) {
return 1;
}
if (hasUnionFilter) {
if (rooted(currentNode, unionNodes)) {
return 1;
}
result = 0;
}
return result;
}
public int isNodeIncludeDO(Node n, int level) {
int result = 1;
if (hasSubtractFilter) {
if (inSubtract == -1 || level <= inSubtract) {
if (inList(n, subtractNodes)) {
inSubtract = level;
} else {
inSubtract = -1;
}
}
if (inSubtract != -1){
result = -1;
}
}
if (result != -1 && hasIntersectFilter
&& (inIntersect == -1 || level <= inIntersect)) {
if (!inList(n, intersectNodes)) {
inIntersect = -1;
result = 0;
} else {
inIntersect = level;
}
}
if (level <= inUnion) {
inUnion = -1;
}
if (result == 1) {
return 1;
}
if (hasUnionFilter) {
if (inUnion == -1 && inList(n, unionNodes)) {
inUnion = level;
}
if (inUnion != -1) {
return 1;
}
result = 0;
}
return result;
}
/**
* Method rooted
* @param currentNode
* @param nodeList
*
* @return if rooted bye the rootnodes
*/
static boolean rooted(Node currentNode, Set nodeList) {
if (nodeList.isEmpty()) {
return false;
}
if (nodeList.contains(currentNode)) {
return true;
}
for (Node rootNode : nodeList) {
if (XMLUtils.isDescendantOrSelf(rootNode, currentNode)) {
return true;
}
}
return false;
}
/**
* Method rooted
* @param currentNode
* @param nodeList
*
* @return if rooted bye the rootnodes
*/
static boolean inList(Node currentNode, Set nodeList) {
return nodeList.contains(currentNode);
}
private static Set convertNodeListToSet(List l) {
Set result = new HashSet();
for (NodeList rootNodes : l) {
int length = rootNodes.getLength();
for (int i = 0; i < length; i++) {
Node rootNode = rootNodes.item(i);
result.add(rootNode);
}
}
return result;
}
}