package at.gv.egovernment.moa.id.util; import iaik.ixsil.util.URI; import iaik.security.ecc.ecdsa.ECDSAParameter; import iaik.security.ecc.ecdsa.ECPublicKey; //import iaik.security.ecc.interfaces.ECDSAPublicKey; import iaik.security.ecc.math.ecgroup.ECGroupFactory; import iaik.security.ecc.math.ecgroup.ECPoint; import iaik.security.ecc.math.ecgroup.EllipticCurve; import iaik.security.ecc.math.ecgroup.ProjectiveCoordinate; //import iaik.security.ecc.math.field.BinaryField; //import iaik.security.ecc.math.field.BinaryFieldValue; import iaik.security.ecc.math.field.Field; import iaik.security.ecc.math.field.FieldElement; import iaik.security.ecc.math.field.FieldFactory; import iaik.security.ecc.math.field.Value; import iaik.security.ecc.parameter.ECCParameterFactory; import iaik.security.ecc.spec.ECCParameterSpec; import java.math.BigInteger; import java.security.PublicKey; import java.util.HashMap; import java.util.Iterator; import java.util.Vector; 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.w3c.dom.NodeList; //import at.gv.cio.identitylink.init.Constants; import at.gv.egovernment.moa.id.util.ECDSAConstants; public class ECDSAKeyValueConverter { //TODO enhance javadoc /** * converter class which can be used to convert ECDSA keys encoded in XML * to a PublicKey data structure * @param keyValueElem ECDSAKeyValue Element * @return ECPublicKey encoded in PublicKey data structure * @throws Exception * * @author gregor karlinger */ public static PublicKey element2ECDSAPublicKey(Element keyValueElem) throws Exception { String ecdsaNS = ECDSAConstants.NAMESPACE_ECDSAKEYVALUE_; // Domain parameters Element domainParams = getChildElement(keyValueElem, ecdsaNS, "DomainParameters", 1); if (domainParams == null) throw new Exception("Domain parameters must not be implicit."); Element namedCurve = getChildElement(domainParams, ecdsaNS, "NamedCurve", 1); ECCParameterSpec eccParameterSpec; if (namedCurve != null) { URI curveNameURN = new URI(namedCurve.getAttributeNS(null, "URN")); ECCParameterFactory eccParamFactory = ECCParameterFactory.getInstance(); eccParameterSpec = eccParamFactory.getParameterByOID(curveNameURN.getPath().substring(4)); } else { Element excplicitParams = getChildElement(domainParams, ecdsaNS, "ExplicitParams", 1); Element fieldParams = getChildElement(excplicitParams, ecdsaNS, "FieldParams", 1); Element curveParams = getChildElement(excplicitParams, ecdsaNS, "CurveParams", 1); Element basePointParams = getChildElement(excplicitParams, ecdsaNS, "BasePointParams", 1); // Field parameters String fieldParamsTypeStr = fieldParams.getAttributeNS(ECDSAConstants.NAMESPACE_XSI_, "type"); String ecdsaNSPrefix = getECDSANSPrefix(fieldParams); BigInteger p = null; int fieldParamsType = 0; final int FIELD_TYPE_PRIME = 1; final int FIELD_TYPE_TNB = 2; final int FIELD_TYPE_PNB = 3; int m = -1, k = -1, k1 = -1, k2 = -1, k3 = -1; if (fieldParamsTypeStr.equals(ecdsaNSPrefix + ":PrimeFieldParamsType")) { fieldParamsType = FIELD_TYPE_PRIME; String pStr = getChildElementText(fieldParams, ecdsaNS, "P", 1); p = new BigInteger(pStr, 10); } else if (fieldParamsTypeStr.equals(ecdsaNSPrefix + ":TnBFieldParamsType")) { fieldParamsType = FIELD_TYPE_TNB; String mStr = getChildElementText(fieldParams, ecdsaNS, "M", 1); m = Integer.parseInt(mStr); String kStr = getChildElementText(fieldParams, ecdsaNS, "K", 1); k = Integer.parseInt(kStr); } else if (fieldParamsTypeStr.equals(ecdsaNSPrefix + ":PnBFieldParamsType")) { fieldParamsType = FIELD_TYPE_PNB; String mStr = getChildElementText(fieldParams, ecdsaNS, "M", 1); m = Integer.parseInt(mStr); String k1Str = getChildElementText(fieldParams, ecdsaNS, "K1", 1); k1 = Integer.parseInt(k1Str); String k2Str = getChildElementText(fieldParams, ecdsaNS, "K2", 1); k2 = Integer.parseInt(k2Str); String k3Str = getChildElementText(fieldParams, ecdsaNS, "K3", 1); k3 = Integer.parseInt(k3Str); } else throw new Exception("Unknown field parameters."); // Curve parameters Element aElem = getChildElement(curveParams, ecdsaNS, "A", 1); String aStr = aElem.getAttributeNS(null, "Value"); Element bElem = getChildElement(curveParams, ecdsaNS, "B", 1); String bStr = bElem.getAttributeNS(null, "Value"); String seedStr = getChildElementText(curveParams, ecdsaNS, "Seed", 1); BigInteger seed = (seedStr != null) ? new BigInteger(seedStr, 10) : null; // Base point parameters Element basePoint = getChildElement(basePointParams, ecdsaNS, "BasePoint", 1); Element basePointXElem = getChildElement(basePoint, ecdsaNS, "X", 1); String basePointXStr = basePointXElem.getAttributeNS(null, "Value"); Element basePointYElem = getChildElement(basePoint, ecdsaNS, "Y", 1); String basePointYStr = basePointYElem.getAttributeNS(null, "Value"); String orderStr = getChildElementText(basePointParams, ecdsaNS, "Order", 1); BigInteger order = new BigInteger(orderStr, 10); String cofactorStr = getChildElementText(basePointParams, ecdsaNS, "Cofactor", 1); BigInteger cofactor = (cofactorStr != null) ? new BigInteger(cofactorStr, 10) : null; if (fieldParamsType == FIELD_TYPE_PRIME) { BigInteger a = new BigInteger(aStr, 10); BigInteger b = new BigInteger(bStr, 10); BigInteger basePointX = new BigInteger(basePointXStr, 10); BigInteger basePointY = new BigInteger(basePointYStr, 10); eccParameterSpec = new ECCParameterSpec(p, cofactor, order, seed, null, a, b, basePointX, basePointY, null); } else { int[] irreducible = new int[m/32 + ((m % 32 != 0) ? 1 : 0)]; if (fieldParamsType == FIELD_TYPE_TNB) { irreducible[m/32] = 1 << m % 32; irreducible[k/32] += 1 << k % 32; irreducible[0] += 1; } else { irreducible[m/32] = 1 << m % 32; irreducible[k3/32] += 1 << k3 % 32; irreducible[k2/32] += 1 << k2 % 32; irreducible[k1/32] += 1 << k1 % 32; irreducible[0] += 1; } eccParameterSpec = new ECCParameterSpec(irreducible, cofactor, order, octetString2IntArray(aStr), octetString2IntArray(bStr), octetString2IntArray(basePointXStr), octetString2IntArray(basePointYStr), null); } } // Public key Element publicKeyElem = getChildElement(keyValueElem, ecdsaNS, "PublicKey", 1); Element publicKeyXElem = getChildElement(publicKeyElem, ecdsaNS, "X", 1); String publicKeyXStr = publicKeyXElem.getAttributeNS(null, "Value"); Element publicKeyYElem = getChildElement(publicKeyElem, ecdsaNS, "Y", 1); String publicKeyYStr = publicKeyYElem.getAttributeNS(null, "Value"); ECDSAParameter ecdsaParams = new ECDSAParameter(eccParameterSpec, false); ECGroupFactory ecGroupFactory = ECGroupFactory.getInstance(); EllipticCurve eCurve = ecGroupFactory.getCurveWithProjective(eccParameterSpec.getA(), eccParameterSpec.getB(), eccParameterSpec.getR()); Field field = eCurve.getField(); // Detect type of public key field elements String elementType = publicKeyXElem.getAttributeNS(ECDSAConstants.NAMESPACE_XSI_, "type"); String elementTypeLocalName = elementType.substring(elementType.indexOf(':') + 1); int FIELD_TYPE_PRIME = 1, FIELD_TYPE_CHAR_TWO = 2; int fieldElemType = ("PrimeFieldElemType".equals(elementTypeLocalName)) ? FIELD_TYPE_PRIME : FIELD_TYPE_CHAR_TWO; FieldElement publicKeyPointX, publicKeyPointY; if (fieldElemType == FIELD_TYPE_PRIME) { Value xValue = FieldFactory.getInstance().getPrimeFieldValue(new BigInteger(publicKeyXStr, 10)); publicKeyPointX = field.newElement(xValue); Value yValue = FieldFactory.getInstance().getPrimeFieldValue(new BigInteger(publicKeyYStr, 10)); publicKeyPointY = field.newElement(yValue); } else { publicKeyPointX = field.newElement(octetString2ByteArray(publicKeyXStr)); publicKeyPointY = field.newElement(octetString2ByteArray(publicKeyYStr)); } ProjectiveCoordinate publicKeyPointCoordinate = new ProjectiveCoordinate(publicKeyPointX, publicKeyPointY, field.getONEelement()); ECPoint publicKeyPoint = eCurve.newPoint(publicKeyPointCoordinate); ECPublicKey publicKey = new ECPublicKey(ecdsaParams, publicKeyPoint); return publicKey; } /* ---------------------------------------------------------------------------------------------------- */ /* public static Element publicKey2ECDSAKeyValueElement(boolean implParams, String curveOID, ECDSAPublicKey publicKey, Document factoryDoc) { String ecdsaNS = ECDSAConstants.NAMESPACE_ECDSAKEYVALUE_; String ecdsaNSP = ECDSAConstants.NS_PREFIX_ECDSAKEYVALUE_; String nsNS = ECDSAConstants.NAMESPACE_NAMESPACES_; String xsiNS = ECDSAConstants.NAMESPACE_XSI_; String xsiNSP = ECDSAConstants.NS_PREFIX_XSI_; ECDSAParameter params = (ECDSAParameter)publicKey.getParameter(); EllipticCurve curve = params.getG().getCurve(); Field field = curve.getField(); int fieldId = curve.getField().getFieldId(); Element eCDSAKeyValue = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":ECDSAKeyValue"); eCDSAKeyValue.setAttributeNS(nsNS, "xmlns:" + ecdsaNSP, ecdsaNS); eCDSAKeyValue.setAttributeNS(nsNS, "xmlns:" + xsiNSP, xsiNS); // Detect field type int coeffPositions[] = new int[3]; int fieldType = 0; String fieldElemTypeString = null; final int FT_PRIME = 1, FT_TNB = 2, FT_PNB = 3; if (fieldId == Field.PRIME_FIELD) { fieldType = FT_PRIME; fieldElemTypeString = ecdsaNSP + ":PrimeFieldElemType"; } else { // Get irreducible polynomal BinaryField binaryField = (BinaryField)field; BinaryFieldValue irreducible = binaryField.getIrreducible(); // Get coefficients of irreducible polynomal int order = irreducible.getOrder(); int coeffCount = 2; for (int i = 1; i < order - 1; i++) { if (irreducible.testBit(i)) { coeffPositions[coeffCount - 2] = i; coeffCount++; if (coeffCount == 5) break; } } // Set polynomal type (TNB or fieldType = (coeffCount == 3) ? FT_TNB : FT_PNB; fieldElemTypeString = ecdsaNSP + ":CharTwoFieldElemType"; } if (!implParams) { Element domainParameters = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":DomainParameters"); eCDSAKeyValue.appendChild(factoryDoc.createTextNode("\n ")); eCDSAKeyValue.appendChild(domainParameters); if (curveOID != null) { // Named curve Element namedCurve = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":NamedCurve"); namedCurve.setAttributeNS(null, "URN", "urn:oid:" + curveOID); domainParameters.appendChild(factoryDoc.createTextNode("\n ")); domainParameters.appendChild(namedCurve); domainParameters.appendChild(factoryDoc.createTextNode("\n ")); } else { // Explicit parameters Element explicitParams = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":ExplicitParams"); // Field parameters Element fieldParams = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":FieldParams"); explicitParams.appendChild(factoryDoc.createTextNode("\n ")); explicitParams.appendChild(fieldParams); if (fieldType == FT_PRIME) { fieldParams.setAttributeNS(xsiNS, xsiNSP + ":type", ecdsaNSP + ":PrimeFieldParamsType"); Element p = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":P"); p.appendChild(factoryDoc.createTextNode(curve.getField().getSize().toString(10))); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); fieldParams.appendChild(p); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); } else if (fieldType == FT_TNB) { fieldParams.setAttributeNS(xsiNS, xsiNSP + ":type", ecdsaNSP + ":TnBFieldParamsType"); Element m = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":M"); m.appendChild(factoryDoc.createTextNode(Integer.toString(curve.getField().getOrder()))); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); fieldParams.appendChild(m); Element k = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":K"); k.appendChild(factoryDoc.createTextNode(Integer.toString(coeffPositions[0], 10))); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); fieldParams.appendChild(k); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); } else { fieldParams.setAttributeNS(xsiNS, xsiNSP + ":type", ecdsaNSP + ":PnBFieldParamsType"); Element m = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":M"); m.appendChild(factoryDoc.createTextNode(Integer.toString(curve.getField().getOrder()))); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); fieldParams.appendChild(m); Element k1 = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":K1"); k1.appendChild(factoryDoc.createTextNode(Integer.toString(coeffPositions[0]))); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); fieldParams.appendChild(k1); Element k2 = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":K2"); k2.appendChild(factoryDoc.createTextNode(Integer.toString(coeffPositions[1]))); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); fieldParams.appendChild(k2); Element k3 = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":K3"); k3.appendChild(factoryDoc.createTextNode(Integer.toString(coeffPositions[2]))); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); fieldParams.appendChild(k3); fieldParams.appendChild(factoryDoc.createTextNode("\n ")); } // Curve parameters Element curveParams = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":CurveParams"); explicitParams.appendChild(factoryDoc.createTextNode("\n ")); explicitParams.appendChild(curveParams); Element a = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":A"); a.setAttributeNS(xsiNS, xsiNSP + ":type", fieldElemTypeString); a.setAttributeNS(null, "Value", (fieldId == Field.PRIME_FIELD) ? curve.getA().getValue().toBigInt().toString(10) : evenStringLength(curve.getA().getValue().toBigInt().toString(16))); curveParams.appendChild(factoryDoc.createTextNode("\n ")); curveParams.appendChild(a); Element b = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":B"); b.setAttributeNS(xsiNS, xsiNSP + ":type", fieldElemTypeString); b.setAttributeNS(null, "Value", (fieldId == Field.PRIME_FIELD) ? curve.getB().getValue().toBigInt().toString(10) : evenStringLength(curve.getB().getValue().toBigInt().toString(16))); curveParams.appendChild(factoryDoc.createTextNode("\n ")); curveParams.appendChild(b); if (params.getS() != null) { Element seed = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":Seed"); seed.appendChild(factoryDoc.createTextNode(evenStringLength(params.getS().toString(16)))); curveParams.appendChild(factoryDoc.createTextNode("\n ")); curveParams.appendChild(seed); } curveParams.appendChild(factoryDoc.createTextNode("\n ")); // Base point params Element basePointParams = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":BasePointParams"); explicitParams.appendChild(factoryDoc.createTextNode("\n ")); explicitParams.appendChild(basePointParams); Element basePoint = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":BasePoint"); basePointParams.appendChild(factoryDoc.createTextNode("\n ")); basePointParams.appendChild(basePoint); Element x = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":X"); x.setAttributeNS(xsiNS, xsiNSP + ":type", fieldElemTypeString); x.setAttributeNS(null, "Value", (fieldId == Field.PRIME_FIELD) ? params.getG().getCoordinates().getX().getValue().toBigInt().toString(10) : evenStringLength(params.getG().getCoordinates().getX().getValue().toBigInt().toString(16))); basePoint.appendChild(factoryDoc.createTextNode("\n ")); basePoint.appendChild(x); Element y = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":Y"); y.setAttributeNS(xsiNS, xsiNSP + ":type", fieldElemTypeString); y.setAttributeNS(null, "Value", (fieldId == Field.PRIME_FIELD) ? params.getG().getCoordinates().getY().getValue().toBigInt().toString(10) : evenStringLength(params.getG().getCoordinates().getY().getValue().toBigInt().toString(16))); basePoint.appendChild(factoryDoc.createTextNode("\n ")); basePoint.appendChild(y); basePoint.appendChild(factoryDoc.createTextNode("\n ")); Element order = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":Order"); order.appendChild(factoryDoc.createTextNode(params.getR().toString(10))); basePointParams.appendChild(factoryDoc.createTextNode("\n ")); basePointParams.appendChild(order); if (params.getK() != null) { Element cofactor = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":Cofactor"); cofactor.appendChild(factoryDoc.createTextNode(params.getK().toString(10))); basePointParams.appendChild(factoryDoc.createTextNode("\n ")); basePointParams.appendChild(cofactor); } basePointParams.appendChild(factoryDoc.createTextNode("\n ")); explicitParams.appendChild(factoryDoc.createTextNode("\n ")); domainParameters.appendChild(factoryDoc.createTextNode("\n ")); domainParameters.appendChild(explicitParams); domainParameters.appendChild(factoryDoc.createTextNode("\n ")); } } // Public key point Element publicKeyPoint = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":PublicKey"); Element publicKeyX = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":X"); publicKeyX.setAttributeNS(xsiNS, xsiNSP + ":type", fieldElemTypeString); publicKeyX.setAttributeNS(null, "Value", (fieldId == Field.PRIME_FIELD) ? publicKey.getW().getCoordinates().getX().getValue().toBigInt().toString(10) : evenStringLength(publicKey.getW().getCoordinates().getX().getValue().toBigInt().toString(16))); publicKeyPoint.appendChild(factoryDoc.createTextNode("\n ")); publicKeyPoint.appendChild(publicKeyX); Element publicKeyY = factoryDoc.createElementNS(ecdsaNS, ecdsaNSP + ":Y"); publicKeyY.setAttributeNS(xsiNS, xsiNSP + ":type", fieldElemTypeString); publicKeyY.setAttributeNS(null, "Value", (fieldId == Field.PRIME_FIELD) ? publicKey.getW().getCoordinates().getY().getValue().toBigInt().toString(10) : evenStringLength(publicKey.getW().getCoordinates().getY().getValue().toBigInt().toString(16))); publicKeyPoint.appendChild(factoryDoc.createTextNode("\n ")); publicKeyPoint.appendChild(publicKeyY); publicKeyPoint.appendChild(factoryDoc.createTextNode("\n ")); eCDSAKeyValue.appendChild(factoryDoc.createTextNode("\n ")); eCDSAKeyValue.appendChild(publicKeyPoint); eCDSAKeyValue.appendChild(factoryDoc.createTextNode("\n ")); return eCDSAKeyValue; } */ /* ---------------------------------------------------------------------------------------------------- */ private static String getECDSANSPrefix(Element element) { // FIXXME: Review this function (GK, 11.06.2002) - should return a list of strings, since more than // one NS prefix can be bound to the ECDSA namespace HashMap inScopeNSAttrs = getInScopeNSAttrs(element); Iterator inScopeNSAttrsIt = inScopeNSAttrs.keySet().iterator(); while (inScopeNSAttrsIt.hasNext()) { Attr currentAttr = (Attr)inScopeNSAttrs.get(inScopeNSAttrsIt.next()); if (ECDSAConstants.NAMESPACE_ECDSAKEYVALUE_.equals(currentAttr.getValue())) { return ("xmlns".equals(currentAttr.getNodeName())) ? "" : currentAttr.getNodeName().substring(6); } } return null; } /* ---------------------------------------------------------------------------------------------------- */ // Converts an octet string representation into an int array as needed for the IAIK ECC library // String: rightmost byte is least significant byte // IntArray: rightmost byte is LEAST significant byte private static int[] octetString2IntArray(String octetString) { int byteCount = octetString.length()/2; int[] intArray = new int[byteCount/4 + ((byteCount % 4 != 0) ? 1 : 0)]; for (int i = 0; i < byteCount; i++) { int oSStartPos = octetString.length() - (i + 1) * 2; int currentByte = Integer.parseInt(octetString.substring(oSStartPos, oSStartPos + 2), 16); intArray[i/4] += (currentByte & 0xFF) << ((i % 4) * 8); } return intArray; } /* ---------------------------------------------------------------------------------------------------- */ // Converts an octet string representation into a byte array as needed for the IAIK ECC library // String: rightmost byte is least significant byte // ByteArray: rightmost byte is MOST significant byte private static byte[] octetString2ByteArray(String octetString) { int byteCount = octetString.length()/2; byte[] byteArray = new byte[byteCount]; for (int i = 0; i < byteCount; i++) { int oSStartPos = octetString.length() - (i + 1) * 2; byteArray[byteCount - i - 1] = (byte) Integer.parseInt(octetString.substring( oSStartPos, oSStartPos + 2), 16); } return byteArray; } /* ---------------------------------------------------------------------------------------------------- */ private static String evenStringLength(String hexString) { return (hexString.length() % 2 != 0) ? "0" + hexString : hexString; } /* ---------------------------------------------------------------------------------------------------- */ private static Element getChildElement(Element parent, String namespace, String localName, int instance) { NodeList namedElements = parent.getElementsByTagNameNS(namespace, localName); if (namedElements.getLength() < instance) return null; return (Element)namedElements.item(instance - 1); } /* ---------------------------------------------------------------------------------------------------- */ private static String getChildElementText(Element parent, String namespace, String localName, int instance) { Element child = getChildElement(parent, namespace, localName, instance); if (child == null) return null; NodeList childNodes = child.getChildNodes(); int nodeCount = 0; while (nodeCount < childNodes.getLength()) { Node currentNode = childNodes.item(nodeCount); if (currentNode.getNodeType() == Node.TEXT_NODE) return currentNode.getNodeValue(); nodeCount++; } return null; } /* ---------------------------------------------------------------------------------------------------- */ public static HashMap getInScopeNSAttrs(Element element) { // Get all ancestors of element Vector ancestors = new Vector(); ancestors.add(element); Node currentAncestor = element; while ((currentAncestor = currentAncestor.getParentNode()) != null && currentAncestor.getNodeType() == Node.ELEMENT_NODE) { ancestors.add(currentAncestor); } // Scan all ancestors for NS attributes HashMap inScopeNSAttrs = new HashMap(); for (int i = ancestors.size() - 1; i >= 0; i--) { Element currentAncestorElem = (Element)ancestors.get(i); NamedNodeMap attrs = currentAncestorElem.getAttributes(); for (int j = 0; j < attrs.getLength(); j++) { Attr currentAttr = (Attr)attrs.item(j); String currentAttrName = currentAttr.getNodeName(); if ("xmlns".equals(currentAttrName) || currentAttrName.startsWith("xmlns:")) { inScopeNSAttrs.put(currentAttrName, currentAttr); } } } // Check if default NS attribute is in list; if value is empty remove it from list Attr defaultNSAttr = (Attr)inScopeNSAttrs.get("xmlns"); if (defaultNSAttr != null && "".equals(defaultNSAttr.getValue())) inScopeNSAttrs.remove("xmlns"); return inScopeNSAttrs; } }