| |
| /* |
| * Copyright 1999-2004 The Apache Software Foundation. |
| * |
| * Licensed 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.c14n.implementations; |
| |
| |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.SortedSet; |
| import java.util.TreeSet; |
| |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| import org.apache.xml.security.c14n.CanonicalizationException; |
| import org.apache.xml.security.c14n.helper.C14nHelper; |
| import org.apache.xml.security.signature.XMLSignatureInput; |
| import org.apache.xml.security.utils.Constants; |
| import org.apache.xml.security.utils.XMLUtils; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.xml.sax.SAXException; |
| |
| |
| /** |
| * Implements <A HREF="http://www.w3.org/TR/2001/REC-xml-c14n-20010315">Canonical |
| * XML Version 1.0</A>, a W3C Recommendation from 15 March 2001. |
| * |
| * @author Christian Geuer-Pollmann <geuerp@apache.org> |
| * @version $Revision$ |
| */ |
| public abstract class Canonicalizer20010315 extends CanonicalizerBase { |
| boolean firstCall=true; |
| final SortedSet result= new TreeSet(COMPARE); |
| static final String XMLNS_URI=Constants.NamespaceSpecNS; |
| static final String XML_LANG_URI=Constants.XML_LANG_SPACE_SpecNS; |
| static class XmlAttrStack { |
| int currentLevel=0; |
| int lastlevel=0; |
| XmlsStackElement cur; |
| static class XmlsStackElement { |
| int level; |
| boolean rendered=false; |
| List nodes=new ArrayList(); |
| }; |
| List levels=new ArrayList(); |
| void push(int level) { |
| currentLevel=level; |
| if (currentLevel==-1) |
| return; |
| cur=null; |
| while (lastlevel>currentLevel) { |
| levels.remove(levels.size()-1); |
| if (levels.size()==0) { |
| lastlevel=0; |
| return; |
| } |
| lastlevel=((XmlsStackElement)levels.get(levels.size()-1)).level; |
| } |
| } |
| void addXmlnsAttr(Attr n) { |
| if (cur==null) { |
| cur=new XmlsStackElement(); |
| cur.level=currentLevel; |
| levels.add(cur); |
| lastlevel=currentLevel; |
| } |
| cur.nodes.add(n); |
| } |
| void getXmlnsAttr(Collection col) { |
| int size=levels.size()-1; |
| if (cur==null) { |
| cur=new XmlsStackElement(); |
| cur.level=currentLevel; |
| lastlevel=currentLevel; |
| levels.add(cur); |
| } |
| boolean parentRendered=false; |
| XmlsStackElement e=null; |
| if (size==-1) { |
| parentRendered=true; |
| } else { |
| e=(XmlsStackElement)levels.get(size); |
| if (e.rendered && e.level+1==currentLevel) |
| parentRendered=true; |
| |
| } |
| if (parentRendered) { |
| col.addAll(cur.nodes); |
| cur.rendered=true; |
| return; |
| } |
| |
| Map loa = new HashMap(); |
| for (;size>=0;size--) { |
| e=(XmlsStackElement)levels.get(size); |
| Iterator it=e.nodes.iterator(); |
| while (it.hasNext()) { |
| Attr n=(Attr)it.next(); |
| if (!loa.containsKey(n.getName())) |
| loa.put(n.getName(),n); |
| } |
| //if (e.rendered) |
| //break; |
| |
| }; |
| //cur.nodes.clear(); |
| //cur.nodes.addAll(loa.values()); |
| cur.rendered=true; |
| col.addAll(loa.values()); |
| } |
| |
| } |
| XmlAttrStack xmlattrStack=new XmlAttrStack(); |
| /** |
| * Constructor Canonicalizer20010315 |
| * |
| * @param includeComments |
| */ |
| public Canonicalizer20010315(boolean includeComments) { |
| super(includeComments); |
| } |
| |
| /** |
| * Returns the Attr[]s to be outputted for the given element. |
| * <br> |
| * The code of this method is a copy of {@link #handleAttributes(Element, |
| * NameSpaceSymbTable)}, |
| * whereas it takes into account that subtree-c14n is -- well -- subtree-based. |
| * So if the element in question isRoot of c14n, it's parent is not in the |
| * node set, as well as all other ancestors. |
| * |
| * @param E |
| * @param ns |
| * @return the Attr[]s to be outputted |
| * @throws CanonicalizationException |
| */ |
| Iterator handleAttributesSubtree(Element E, NameSpaceSymbTable ns ) |
| throws CanonicalizationException { |
| if (!E.hasAttributes() && !firstCall) { |
| return null; |
| } |
| // result will contain the attrs which have to be outputted |
| final SortedSet result = this.result; |
| result.clear(); |
| NamedNodeMap attrs = E.getAttributes(); |
| int attrsLength = attrs.getLength(); |
| |
| for (int i = 0; i < attrsLength; i++) { |
| Attr N = (Attr) attrs.item(i); |
| String NUri =N.getNamespaceURI(); |
| |
| if (XMLNS_URI!=NUri) { |
| //It's not a namespace attr node. Add to the result and continue. |
| result.add(N); |
| continue; |
| } |
| |
| String NName=N.getLocalName(); |
| String NValue=N.getValue(); |
| if (XML.equals(NName) |
| && XML_LANG_URI.equals(NValue)) { |
| //The default mapping for xml must not be output. |
| continue; |
| } |
| |
| Node n=ns.addMappingAndRender(NName,NValue,N); |
| |
| if (n!=null) { |
| //Render the ns definition |
| result.add(n); |
| if (C14nHelper.namespaceIsRelative(N)) { |
| Object exArgs[] = { E.getTagName(), NName, N.getNodeValue() }; |
| throw new CanonicalizationException( |
| "c14n.Canonicalizer.RelativeNamespace", exArgs); |
| } |
| } |
| } |
| |
| if (firstCall) { |
| //It is the first node of the subtree |
| //Obtain all the namespaces defined in the parents, and added to the output. |
| ns.getUnrenderedNodes(result); |
| //output the attributes in the xml namespace. |
| xmlattrStack.getXmlnsAttr(result); |
| firstCall=false; |
| } |
| |
| return result.iterator(); |
| } |
| |
| /** |
| * Returns the Attr[]s to be outputted for the given element. |
| * <br> |
| * IMPORTANT: This method expects to work on a modified DOM tree, i.e. a DOM which has |
| * been prepared using {@link org.apache.xml.security.utils.XMLUtils#circumventBug2650( |
| * org.w3c.dom.Document)}. |
| * |
| * @param E |
| * @param ns |
| * @return the Attr[]s to be outputted |
| * @throws CanonicalizationException |
| */ |
| Iterator handleAttributes(Element E, NameSpaceSymbTable ns ) throws CanonicalizationException { |
| // result will contain the attrs which have to be outputted |
| xmlattrStack.push(ns.getLevel()); |
| boolean isRealVisible=isVisibleDO(E,ns.getLevel())==1; |
| NamedNodeMap attrs = null; |
| int attrsLength = 0; |
| if (E.hasAttributes()) { |
| attrs=E.getAttributes(); |
| attrsLength= attrs.getLength(); |
| } |
| |
| |
| SortedSet result = this.result; |
| result.clear(); |
| |
| for (int i = 0; i < attrsLength; i++) { |
| Attr N = (Attr) attrs.item(i); |
| String NUri =N.getNamespaceURI(); |
| |
| if (XMLNS_URI!=NUri) { |
| //A non namespace definition node. |
| if (XML_LANG_URI==NUri) { |
| xmlattrStack.addXmlnsAttr(N); |
| } else if (isRealVisible){ |
| //The node is visible add the attribute to the list of output attributes. |
| result.add(N); |
| } |
| //keep working |
| continue; |
| } |
| |
| String NName=N.getLocalName(); |
| String NValue=N.getValue(); |
| if ("xml".equals(NName) |
| && XML_LANG_URI.equals(NValue)) { |
| /* except omit namespace node with local name xml, which defines |
| * the xml prefix, if its string value is http://www.w3.org/XML/1998/namespace. |
| */ |
| continue; |
| } |
| //add the prefix binding to the ns symb table. |
| //ns.addInclusiveMapping(NName,NValue,N,isRealVisible); |
| if (isVisible(N)) { |
| if (!isRealVisible && ns.removeMappingIfRender(NName)) { |
| continue; |
| } |
| //The xpath select this node output it if needed. |
| //Node n=ns.addMappingAndRenderXNodeSet(NName,NValue,N,isRealVisible); |
| Node n=ns.addMappingAndRender(NName,NValue,N); |
| if (n!=null) { |
| result.add(n); |
| if (C14nHelper.namespaceIsRelative(N)) { |
| Object exArgs[] = { E.getTagName(), NName, N.getNodeValue() }; |
| throw new CanonicalizationException( |
| "c14n.Canonicalizer.RelativeNamespace", exArgs); |
| } |
| } |
| } else { |
| if (isRealVisible && NName!=XMLNS) { |
| ns.removeMapping(NName); |
| } else { |
| ns.addMapping(NName,NValue,N); |
| } |
| } |
| } |
| if (isRealVisible) { |
| //The element is visible, handle the xmlns definition |
| Attr xmlns = E.getAttributeNodeNS(XMLNS_URI, XMLNS); |
| Node n=null; |
| if (xmlns == null) { |
| //No xmlns def just get the already defined. |
| n=ns.getMapping(XMLNS); |
| } else if ( !isVisible(xmlns)) { |
| //There is a definition but the xmlns is not selected by the xpath. |
| //then xmlns="" |
| n=ns.addMappingAndRender(XMLNS,"",nullNode); |
| } |
| //output the xmlns def if needed. |
| if (n!=null) { |
| result.add(n); |
| } |
| //Float all xml:* attributes of the unselected parent elements to this one. |
| //addXmlAttributes(E,result); |
| xmlattrStack.getXmlnsAttr(result); |
| ns.getUnrenderedNodes(result); |
| |
| } |
| |
| return result.iterator(); |
| } |
| /** |
| * Always throws a CanonicalizationException because this is inclusive c14n. |
| * |
| * @param xpathNodeSet |
| * @param inclusiveNamespaces |
| * @return none it always fails |
| * @throws CanonicalizationException always |
| */ |
| public byte[] engineCanonicalizeXPathNodeSet(Set xpathNodeSet, String inclusiveNamespaces) |
| throws CanonicalizationException { |
| |
| /** $todo$ well, should we throw UnsupportedOperationException ? */ |
| throw new CanonicalizationException( |
| "c14n.Canonicalizer.UnsupportedOperation"); |
| } |
| |
| /** |
| * Always throws a CanonicalizationException because this is inclusive c14n. |
| * |
| * @param rootNode |
| * @param inclusiveNamespaces |
| * @return none it always fails |
| * @throws CanonicalizationException |
| */ |
| public byte[] engineCanonicalizeSubTree(Node rootNode, String inclusiveNamespaces) |
| throws CanonicalizationException { |
| |
| /** $todo$ well, should we throw UnsupportedOperationException ? */ |
| throw new CanonicalizationException( |
| "c14n.Canonicalizer.UnsupportedOperation"); |
| } |
| void circumventBugIfNeeded(XMLSignatureInput input) throws CanonicalizationException, ParserConfigurationException, IOException, SAXException { |
| if (!input.isNeedsToBeExpanded()) |
| return; |
| Document doc = null; |
| if (input.getSubNode() != null) { |
| doc=XMLUtils.getOwnerDocument(input.getSubNode()); |
| } else { |
| doc=XMLUtils.getOwnerDocument(input.getNodeSet()); |
| } |
| XMLUtils.circumventBug2650(doc); |
| |
| } |
| |
| void handleParent(Element e, NameSpaceSymbTable ns) { |
| if (!e.hasAttributes()) { |
| return; |
| } |
| xmlattrStack.push(-1); |
| NamedNodeMap attrs = e.getAttributes(); |
| int attrsLength = attrs.getLength(); |
| for (int i = 0; i < attrsLength; i++) { |
| Attr N = (Attr) attrs.item(i); |
| if (Constants.NamespaceSpecNS!=N.getNamespaceURI()) { |
| //Not a namespace definition, ignore. |
| if (XML_LANG_URI==N.getNamespaceURI()) { |
| xmlattrStack.addXmlnsAttr(N); |
| } |
| continue; |
| } |
| |
| String NName=N.getLocalName(); |
| String NValue=N.getNodeValue(); |
| if (XML.equals(NName) |
| && Constants.XML_LANG_SPACE_SpecNS.equals(NValue)) { |
| continue; |
| } |
| ns.addMapping(NName,NValue,N); |
| } |
| } |
| } |
