ECDSA Key handling classes

git-svn-id: https://joinup.ec.europa.eu/svn/moa-idspss/trunk@238 d688527b-c9ab-4aba-bd8d-4036d912da1d

2 files changed, 609 insertions, 0 deletions

diff --git a/id.server/src/at/gv/egovernment/moa/id/util/ECDSAConstants.java b/id.server/src/at/gv/egovernment/moa/id/util/ECDSAConstants.java
new file mode 100644
index 000000000..057f56a04
--- /dev/null
+++ b/id.server/src/at/gv/egovernment/moa/id/util/ECDSAConstants.java
@@ -0,0 +1,35 @@
+/*
+ * Created on 20.01.2005
+ *
+ * @author rschamberger
+ * $ID$
+ */
+package at.gv.egovernment.moa.id.util;
+
+
+/**
+ * Class used to define Constants used in Class ECDSAKeyValueConverter
+ * 
+ *  * @author rschamberger
+ */
+public class ECDSAConstants {
+       
+    //TODO change to correct NS as soon BMI updates IdentityLink
+    static String NAMESPACE_ECDSAKEYVALUE_ = "http://www.w3.org/2004/01/xmldsig-more#";
+    
+    /* Schema instance NS
+     */
+    static String NAMESPACE_XSI_ = "http://www.w3.org/2001/XMLSchema-instance";
+    
+    /* ecdsa prefix value
+     */
+    static String NS_PREFIX_ECDSAKEYVALUE_ = "ecdsa";
+
+    /* namespace namespace
+     */
+    static String NAMESPACE_NAMESPACES_ = "http://www.w3.org/XML/1998/namespace";
+
+    /* si prefix value
+     */
+    static String NS_PREFIX_XSI_ = "si";
+};
diff --git a/id.server/src/at/gv/egovernment/moa/id/util/ECDSAKeyValueConverter.java b/id.server/src/at/gv/egovernment/moa/id/util/ECDSAKeyValueConverter.java
new file mode 100644
index 000000000..ca609a027
--- /dev/null
+++ b/id.server/src/at/gv/egovernment/moa/id/util/ECDSAKeyValueConverter.java
@@ -0,0 +1,574 @@
+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;
+  }
+}
\ No newline at end of file