Initial import.

git-svn-id: https://joinup.ec.europa.eu/svn/mocca/trunk@1 8a26b1a7-26f0-462f-b9ef-d0e30c41f5a4

33 files changed, 3731 insertions, 0 deletions

diff --git a/utils/src/main/java/at/gv/egiz/bku/local/ui/BKUControllerInterface.java b/utils/src/main/java/at/gv/egiz/bku/local/ui/BKUControllerInterface.java
new file mode 100644
index 00000000..5e191c79
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/local/ui/BKUControllerInterface.java
@@ -0,0 +1,23 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.local.ui;

+

+public interface BKUControllerInterface {

+  

+  public void shutDown();

+

+}

diff --git a/utils/src/main/java/at/gv/egiz/bku/local/ui/TrayIconDialog.java b/utils/src/main/java/at/gv/egiz/bku/local/ui/TrayIconDialog.java
new file mode 100644
index 00000000..5aa74d99
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/local/ui/TrayIconDialog.java
@@ -0,0 +1,202 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.local.ui;

+

+import java.awt.AWTException;

+import java.awt.Image;

+import java.awt.MenuItem;

+import java.awt.PopupMenu;

+import java.awt.SystemTray;

+import java.awt.TrayIcon;

+import java.awt.event.ActionEvent;

+import java.awt.event.ActionListener;

+import java.io.IOException;

+import java.lang.reflect.InvocationHandler;

+import java.lang.reflect.Method;

+import java.lang.reflect.Proxy;

+import java.util.ResourceBundle;

+

+import javax.imageio.ImageIO;

+

+import org.apache.commons.logging.Log;

+import org.apache.commons.logging.LogFactory;

+

+public class TrayIconDialog implements TrayIconDialogInterface {

+

+  private static Log log = LogFactory.getLog(TrayIconDialog.class);

+  private static TrayIconDialogInterface instance;

+  private boolean isSupported;

+  private BKUControllerInterface shutDown;

+  private TrayIcon trayIcon = null;

+  private ResourceBundle resourceBundle = null;

+

+  private TrayIconDialog() {

+  }

+

+  private void displayTrayMsg(String captionID, String messageID,

+      TrayIcon.MessageType type) {

+    if ((isSupported) && (resourceBundle != null)) {

+      try {

+        trayIcon.displayMessage(resourceBundle.getString(captionID),

+            resourceBundle.getString(messageID), type);

+      } catch (Exception ex) {

+        log.error(ex);

+      }

+    }

+  }

+

+  /*

+   * (non-Javadoc)

+   * 

+   * @see

+   * at.gv.egiz.bku.local.ui.TrayIconDialogInterface#displayInfo(java.lang.String

+   * , java.lang.String)

+   */

+  public void displayInfo(String captionID, String messageID) {

+    displayTrayMsg(captionID, messageID, TrayIcon.MessageType.INFO);

+  }

+

+  /*

+   * (non-Javadoc)

+   * 

+   * @see

+   * at.gv.egiz.bku.local.ui.TrayIconDialogInterface#displayWarning(java.lang

+   * .String, java.lang.String)

+   */

+  public void displayWarning(String captionID, String messageID) {

+    displayTrayMsg(captionID, messageID, TrayIcon.MessageType.WARNING);

+  }

+

+  /*

+   * (non-Javadoc)

+   * 

+   * @see

+   * at.gv.egiz.bku.local.ui.TrayIconDialogInterface#displayError(java.lang.

+   * String, java.lang.String)

+   */

+  public void displayError(String captionID, String messageID) {

+    displayTrayMsg(captionID, messageID, TrayIcon.MessageType.ERROR);

+  }

+

+  /*

+   * (non-Javadoc)

+   * 

+   * @see

+   * at.gv.egiz.bku.local.ui.TrayIconDialogInterface#init(java.util.ResourceBundle

+   * )

+   */

+  public void init(ResourceBundle resourceBundel) {

+    this.resourceBundle = resourceBundel;

+    isSupported = SystemTray.isSupported();

+    log.info("Trayicon supported: " + isSupported);

+    try {

+      if (isSupported) {

+        SystemTray tray = SystemTray.getSystemTray();

+        Image image = ImageIO.read(getClass().getClassLoader()

+            .getResourceAsStream("at/gv/egiz/bku/local/ui/chipperling.png"));

+        PopupMenu popup = new PopupMenu();

+        MenuItem exitItem = new MenuItem(resourceBundel

+            .getString("TrayMenu.Shutdown"));

+        popup.add(exitItem);

+        exitItem.addActionListener(new ActionListener() {

+          public void actionPerformed(ActionEvent e) {

+            log.info("Calling Shutdown");

+            if (shutDown != null) {

+              shutDown.shutDown();

+            }

+          }

+        });

+

+        trayIcon = new TrayIcon(image, "BKULogo", popup);

+        trayIcon.setImageAutoSize(true);

+        trayIcon.setToolTip(resourceBundel.getString("TrayMenu.Tooltip"));

+        try {

+          tray.add(trayIcon);

+        } catch (AWTException e) {

+          log.error("TrayIcon could not be added.", e);

+          isSupported = false;

+        }

+      }

+    } catch (IOException e) {

+      log.error(e);

+    }

+  }

+

+  /*

+   * (non-Javadoc)

+   * 

+   * @see

+   * at.gv.egiz.bku.local.ui.TrayIconDialogInterface#setShutdownHook(at.gv.egiz

+   * .bku.local.ui.BKUControllerInterface)

+   */

+  public void setShutdownHook(BKUControllerInterface shutDown) {

+    this.shutDown = shutDown;

+  }

+

+  @SuppressWarnings("unchecked")

+  public synchronized static TrayIconDialogInterface getInstance() {

+    ClassLoader cl = TrayIconDialog.class.getClassLoader();

+    if (instance == null) {

+      if (cl.toString().startsWith("sun.")) {

+        instance = new TrayIconDialog();

+        return instance;

+      }

+      ClassLoader parent = cl;

+      while (!parent.toString().startsWith("sun.")) {

+        parent = parent.getParent();

+      }

+      try {

+        Class<TrayIconDialog> otherClassInstance = (Class<TrayIconDialog>) parent

+            .loadClass(TrayIconDialog.class.getName());

+        Method getInstanceMethod = otherClassInstance.getDeclaredMethod(

+            "getInstance", new Class[] {});

+        Object otherSingleton = getInstanceMethod.invoke(null, new Object[] {});

+        instance = (TrayIconDialogInterface) Proxy.newProxyInstance(cl,

+            new Class[] { TrayIconDialogInterface.class },

+            new PassThroughProxyHandler(otherSingleton));

+      } catch (ClassNotFoundException ce) {

+        instance = new TrayIconDialog();

+      } catch (Exception e) {

+        log.error(e);

+        instance = new TrayIconDialog();

+      }

+      return instance;

+    }

+    return instance;

+  }

+

+  /**

+   * 

+   * Only works for public methods

+   * 

+   */

+  static class PassThroughProxyHandler implements InvocationHandler {

+    private final Object delegate;

+

+    public PassThroughProxyHandler(Object delegate) {

+      this.delegate = delegate;

+    }

+

+    public Object invoke(Object proxy, Method method, Object[] args)

+        throws Throwable {

+      Method delegateMethod = delegate.getClass().getMethod(method.getName(),

+          method.getParameterTypes());

+      return delegateMethod.invoke(delegate, args);

+    }

+  }

+

+}

diff --git a/utils/src/main/java/at/gv/egiz/bku/local/ui/TrayIconDialogInterface.java b/utils/src/main/java/at/gv/egiz/bku/local/ui/TrayIconDialogInterface.java
new file mode 100644
index 00000000..87c64102
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/local/ui/TrayIconDialogInterface.java
@@ -0,0 +1,33 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.local.ui;

+

+import java.util.ResourceBundle;

+

+public interface TrayIconDialogInterface {

+

+  public abstract void displayInfo(String captionID, String messageID);

+

+  public abstract void displayWarning(String captionID, String messageID);

+

+  public abstract void displayError(String captionID, String messageID);

+

+  public abstract void init(ResourceBundle resourceBundel);

+

+  public abstract void setShutdownHook(BKUControllerInterface shutDown);

+

+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/HexDump.java b/utils/src/main/java/at/gv/egiz/bku/utils/HexDump.java
new file mode 100644
index 00000000..88d49bad
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/HexDump.java
@@ -0,0 +1,75 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils;

+

+import java.io.IOException;

+import java.io.InputStream;

+import java.io.StringWriter;

+import java.io.Writer;

+

+public class HexDump {

+  

+  public static String hexDump(InputStream is) throws IOException {

+    StringWriter writer = new StringWriter();

+    hexDump(is, writer);

+    return writer.toString();

+  }

+  

+  public static void hexDump(InputStream is, Writer writer) throws IOException {

+    hexDump(is, writer, 16);

+  }

+  

+  public static void hexDump(InputStream is, Writer writer, int chunkSize) throws IOException {

+    

+    byte[] chunk = new byte[chunkSize];

+    long adr = 0;

+    for (int l; (l = is.read(chunk)) != -1;) {

+      

+      writer.append(String.format("[%06x]", adr));

+      for (int i = 0; i < l; i++) {

+        if (i % 8 == 0) {

+          writer.append(" ");

+        } else {

+          writer.append(":");

+        }

+        writer.append(Integer.toHexString((chunk[i] & 240) >> 4));

+        writer.append(Integer.toHexString(chunk[i] & 15));

+      }

+

+      for (int i = 0; i < (chunkSize - l); i++) {

+        writer.append("   ");

+      }

+      

+      for (int i = 0; i < l; i++) {

+        if (i % 8 == 0) {

+          writer.append(" ");

+        }

+        if (chunk[i] > 31 && chunk[i] < 127) {

+          writer.append((char) chunk[i]);

+        } else {

+          writer.append(".");

+        }

+      }

+

+      writer.append("\n");

+      adr += l;

+      

+    }

+    

+  }

+

+}

diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/StreamUtil.java b/utils/src/main/java/at/gv/egiz/bku/utils/StreamUtil.java
new file mode 100644
index 00000000..a774df2b
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/StreamUtil.java
@@ -0,0 +1,101 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils;

+

+import java.io.ByteArrayOutputStream;

+import java.io.IOException;

+import java.io.InputStream;

+import java.io.OutputStream;

+import java.io.Reader;

+import java.io.Writer;

+

+public class StreamUtil {

+

+  /**

+   * Copies data. None of the streams will be closed.

+   * 

+   * @param is

+   * @param os

+   * @throws IOException

+   */

+  public static void copyStream(InputStream is, OutputStream os)

+      throws IOException {

+    copyStream(is, os, 1024);

+  }

+

+  /**

+   * Copies data. None of the streams will be closed.

+   * 

+   * @param is

+   * @param os

+   * @throws IOException

+   */

+  public static void copyStream(InputStream is, OutputStream os, int bufferSize)

+      throws IOException {

+    byte[] buffer = new byte[bufferSize];

+    copyStream(is, os, buffer);

+  }

+

+  /**

+   * Copies data. None of the streams will be closed.

+   * 

+   * @param is

+   * @param os

+   * @throws IOException

+   */

+  public static void copyStream(InputStream is, OutputStream os, byte[] buffer)

+      throws IOException {

+    for (int i = is.read(buffer); i > -1; i = is.read(buffer)) {

+      os.write(buffer, 0, i);

+    }

+  }

+  

+  /**

+   * Copies data. None of the streams will be closed.

+   * 

+   * @param is

+   * @param os

+   * @throws IOException

+   */

+  public static void copyStream(Reader is, Writer os)

+      throws IOException {

+    copyStream(is, os, 1024);

+  }

+

+  /**

+   * Copies data. None of the streams will be closed.

+   * 

+   * @param is

+   * @param os

+   * @throws IOException

+   */

+  public static void copyStream(Reader is, Writer os, int bufferSize)

+      throws IOException {

+    char[] chars = new char[bufferSize];

+    for (int i = is.read(chars); i > -1; i = is.read(chars)) {

+      os.write(chars, 0, i);

+    }

+  }

+

+  

+  public static String asString(InputStream is, String charset)

+      throws IOException {

+    ByteArrayOutputStream os = new ByteArrayOutputStream();

+    copyStream(is, os);

+    return new String(os.toByteArray(), charset);

+  }

+}

diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/binding/Protocol.java b/utils/src/main/java/at/gv/egiz/bku/utils/binding/Protocol.java
new file mode 100644
index 00000000..f0504697
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/binding/Protocol.java
@@ -0,0 +1,41 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils.binding;

+

+public enum Protocol {

+  HTTP("http"), HTTPS("https");

+  

+  private String name;

+  

+  Protocol(String s) {

+    name = s;

+  }

+  

+  public String toString() {

+    return name;

+  }

+  

+  public static Protocol fromString(String protocol) {

+    if (HTTP.toString().equalsIgnoreCase(protocol)) {

+      return HTTP;

+    }

+    if (HTTPS.toString().equalsIgnoreCase(protocol)) {

+      return HTTPS;

+    }

+    return null;

+  }

+}

diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/FormDataURLSupplier.java b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/FormDataURLSupplier.java
new file mode 100644
index 00000000..7272f1bb
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/FormDataURLSupplier.java
@@ -0,0 +1,26 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils.urldereferencer;

+

+import java.io.InputStream;

+

+public interface FormDataURLSupplier {

+  public static final String PROPERTY_KEY_NAME = "at.gv.egiz.bku.util.urldereferencer.FormDataURLSupplier";

+

+  public InputStream getFormData(String aParameterName);

+  public String getFormDataContentType(String aParameterName);

+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/HTTPURLProtocolHandlerImpl.java b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/HTTPURLProtocolHandlerImpl.java
new file mode 100644
index 00000000..5cba2e1d
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/HTTPURLProtocolHandlerImpl.java
@@ -0,0 +1,76 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils.urldereferencer;

+

+import java.io.IOException;

+import java.io.InputStream;

+import java.net.HttpURLConnection;

+import java.net.URL;

+import java.security.InvalidParameterException;

+

+import org.apache.commons.logging.Log;

+import org.apache.commons.logging.LogFactory;

+

+public class HTTPURLProtocolHandlerImpl implements URLProtocolHandler {

+

+  private static Log log = LogFactory.getLog(HTTPURLProtocolHandlerImpl.class);

+

+  public final static String HTTP = "http";

+  public final static String HTTPS = "https";

+  public final static String FORMDATA = "formdata";

+  public final static String[] PROTOCOLS = { HTTP, HTTPS, FORMDATA };

+

+  public StreamData dereference(String aUrl, URLDereferencerContext aContext)

+      throws IOException {

+    String urlString = aUrl.toLowerCase().trim();

+    if (urlString.startsWith(FORMDATA)) {

+      log.debug("Requested to dereference a formdata url");

+      return dereferenceFormData(aUrl, aContext);

+    }

+

+    URL url = new URL(aUrl);

+    if ((!HTTP.equalsIgnoreCase(url.getProtocol()) && (!HTTPS

+        .equalsIgnoreCase(url.getProtocol())))) {

+      throw new InvalidParameterException("Url " + aUrl + " not supported");

+    }

+    return dereferenceHTTP(url);

+  }

+

+  protected StreamData dereferenceHTTP(URL url) throws IOException {

+    HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();

+    return new StreamData(url.toString(), httpConn.getContentType(), httpConn

+        .getInputStream());

+  }

+

+  protected StreamData dereferenceFormData(String aUrl,

+      URLDereferencerContext aContext) throws IOException {

+    log.debug("Dereferencing formdata url: " + aUrl);

+    String[] parts = aUrl.split(":", 2);

+    FormDataURLSupplier supplier = (FormDataURLSupplier) aContext

+        .getProperty(FormDataURLSupplier.PROPERTY_KEY_NAME);

+    if (supplier == null) {

+      throw new NullPointerException(

+          "No FormdataUrlSupplier found in provided context");

+    }

+    String contentType = supplier.getFormDataContentType(parts[1]);

+    InputStream is = supplier.getFormData(parts[1]);

+    if (is != null) {

+      return new StreamData(aUrl, contentType, is);

+    }

+    return null;

+  }

+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/SimpleFormDataContextImpl.java b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/SimpleFormDataContextImpl.java
new file mode 100644
index 00000000..e9da9c81
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/SimpleFormDataContextImpl.java
@@ -0,0 +1,41 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils.urldereferencer;

+

+public class SimpleFormDataContextImpl implements URLDereferencerContext {

+  protected FormDataURLSupplier formdata;

+  

+  /**

+   * 

+   * @param formdata must not be null

+   */

+  public SimpleFormDataContextImpl(FormDataURLSupplier formdata) {

+    if (formdata == null) {

+      throw new NullPointerException("FormdataURLSupplier must not be null");

+    }

+    this.formdata = formdata;

+  }

+

+  @Override

+  public Object getProperty(Object key) {

+    if (key.equals(FormDataURLSupplier.PROPERTY_KEY_NAME)) {

+      return formdata;

+    }   

+    return null;

+  }

+

+}

diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/StreamData.java b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/StreamData.java
new file mode 100644
index 00000000..541c6878
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/StreamData.java
@@ -0,0 +1,61 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils.urldereferencer;

+

+import java.io.InputStream;

+

+/**

+ * This class models the result when dereferencing an URL. 

+ *

+ */

+public class StreamData {

+

+  protected InputStream inputStream;

+  protected String url;

+  protected String contentType;

+

+  /**

+   * 

+   * @param url

+   * @param contentType

+   * @param stream must not be null

+   */

+  public StreamData(String url, String contentType, InputStream stream) {

+    if (stream == null) {

+      throw new NullPointerException("Parameter inputstream must not be null");

+    }

+    inputStream = stream;

+    this.contentType = contentType;

+    this.url = url;

+  }

+

+  public String getUrl() {

+    return url;

+  }

+

+  /**

+   * 

+   * @return the returned stream must be closed

+   */

+  public InputStream getStream() {

+    return inputStream;

+  }

+

+  public String getContentType() {

+    return contentType;

+  } 

+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URIResolverAdapter.java b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URIResolverAdapter.java
new file mode 100644
index 00000000..2d11010e
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URIResolverAdapter.java
@@ -0,0 +1,96 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils.urldereferencer;

+

+import java.io.IOException;

+import java.net.URI;

+import java.net.URISyntaxException;

+

+import javax.xml.transform.Source;

+import javax.xml.transform.TransformerException;

+import javax.xml.transform.URIResolver;

+import javax.xml.transform.stream.StreamSource;

+

+import org.apache.commons.logging.Log;

+import org.apache.commons.logging.LogFactory;

+

+/**

+ * Adapter to make the Urldereferencer work as URIResolver for

+ * Stylesheettransforms.

+ * 

+ * @author wbauer

+ * 

+ */

+public class URIResolverAdapter implements URIResolver {

+  

+  private static Log log = LogFactory.getLog(URIResolverAdapter.class);

+

+  private URLDereferencer urlDereferencer;

+  private URLDereferencerContext ctx;

+

+  /**

+   * 

+   * @param deferecencer

+   *          must not be null

+   * @param ctx may be null

+   */

+  public URIResolverAdapter(URLDereferencer deferecencer,

+      URLDereferencerContext ctx) {

+    if (deferecencer == null) {

+      throw new NullPointerException("Urlderefencer must not be set to null");

+    }

+    this.urlDereferencer = deferecencer;

+    this.ctx = ctx;

+  }

+

+  @Override

+  public Source resolve(String href, String base) throws TransformerException {

+    log.debug("Resolving href: "+href+" base: "+base);

+    try {

+      URI baseUri = null;

+      URI hrefUri = new URI(href);

+      if (base != null) {

+        baseUri = new URI(base);

+      }

+      URI abs;

+      if (baseUri != null) {

+        abs = baseUri.resolve(hrefUri);

+      } else {

+        abs = hrefUri;

+      }

+      if (!abs.isAbsolute()) {

+        throw new TransformerException("Only absolute URLs are supported");

+      }

+      return new StreamSource(urlDereferencer.dereference(abs.toString(), ctx)

+          .getStream());

+    } catch (URISyntaxException e) {

+      throw new TransformerException("Cannot resolve URI: base:" + base

+          + " href:" + href, e);

+    } catch (IOException iox) {

+      throw new TransformerException("Cannot resolve URI: base:" + base

+          + " href:" + href, iox);

+    }

+  }

+

+  public URLDereferencerContext getCtx() {

+    return ctx;

+  }

+

+  public void setCtx(URLDereferencerContext ctx) {

+    this.ctx = ctx;

+  }

+}

diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URLDereferencer.java b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URLDereferencer.java
new file mode 100644
index 00000000..d747753f
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URLDereferencer.java
@@ -0,0 +1,90 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils.urldereferencer;

+

+import java.io.IOException;

+import java.net.MalformedURLException;

+import java.util.HashMap;

+import java.util.Map;

+

+import org.apache.commons.logging.Log;

+import org.apache.commons.logging.LogFactory;

+

+/**

+ * Class used to dereference (external URLs).

+ * 

+ * @author wbauer

+ * 

+ */

+public class URLDereferencer {

+

+  private static Log log = LogFactory.getLog(URLDereferencer.class);

+

+  private static URLDereferencer instance = new URLDereferencer();

+

+  private Map<String, URLProtocolHandler> handlerMap = new HashMap<String, URLProtocolHandler>();

+

+  private URLDereferencer() {

+    registerHandlers();

+  }

+

+  /**

+   * 

+   * @param aUrl

+   *          must not be null

+   * @param aContext

+   * @throws MalformedURLException

+   *           if the protocol is not supported

+   */

+  public StreamData dereference(String aUrl, URLDereferencerContext aContext)

+      throws IOException {

+    log.debug("Looking for handler for URL: " + aUrl);

+    int i = aUrl.indexOf(":");

+    if (i == -1) {

+      throw new MalformedURLException("Invalid url: " + aUrl);

+    }

+    String protocol = aUrl.substring(0, i).toLowerCase().trim();

+    URLProtocolHandler handler = handlerMap.get(protocol);

+    if (handler == null) {

+      throw new MalformedURLException("No handler for protocol: " + protocol

+          + " found");

+    }

+    return handler.dereference(aUrl, aContext);

+  }

+

+  /**

+   * Registers a handler for a protocol.

+   * 

+   * @param aProtocol

+   * @param aHandler

+   *          may be set to null to disable this protocol

+   */

+  public void registerHandler(String aProtocol, URLProtocolHandler aHandler) {

+    handlerMap.put(aProtocol.toLowerCase(), aHandler);

+  }

+

+  public static URLDereferencer getInstance() {

+    return instance;

+  }

+

+  protected void registerHandlers() {

+    URLProtocolHandler handler = new HTTPURLProtocolHandlerImpl();

+    for (String proto : HTTPURLProtocolHandlerImpl.PROTOCOLS) {

+      handlerMap.put(proto, handler);

+    }

+  }

+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URLDereferencerContext.java b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URLDereferencerContext.java
new file mode 100644
index 00000000..6befd5b3
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URLDereferencerContext.java
@@ -0,0 +1,27 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils.urldereferencer;

+

+public interface URLDereferencerContext {

+

+  /**

+   * 

+   * @param key

+   * @return may return null

+   */

+  public Object getProperty(Object key);

+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URLProtocolHandler.java b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URLProtocolHandler.java
new file mode 100644
index 00000000..f584f450
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/bku/utils/urldereferencer/URLProtocolHandler.java
@@ -0,0 +1,32 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.bku.utils.urldereferencer;

+

+import java.io.IOException;

+import java.net.MalformedURLException;

+

+

+public interface URLProtocolHandler {

+  /**

+   * 

+   * @param aUrl

+   * @param aContext

+   * @return the streamdata of this url or null if the url cannot be resolved.

+   * @throws IOException

+   */

+  public StreamData dereference(String aUrl, URLDereferencerContext aContext) throws IOException;

+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/dom/DOMUtils.java b/utils/src/main/java/at/gv/egiz/dom/DOMUtils.java
new file mode 100644
index 00000000..32c7c5e6
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/dom/DOMUtils.java
@@ -0,0 +1,115 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.dom;

+

+import iaik.utils.Base64OutputStream;

+

+import java.io.ByteArrayOutputStream;

+import java.io.IOException;

+import java.io.InputStream;

+

+import javax.xml.parsers.DocumentBuilder;

+import javax.xml.parsers.DocumentBuilderFactory;

+import javax.xml.parsers.ParserConfigurationException;

+

+import org.w3c.dom.Document;

+import org.w3c.dom.Text;

+import org.w3c.dom.bootstrap.DOMImplementationRegistry;

+import org.w3c.dom.ls.DOMImplementationLS;

+

+public final class DOMUtils {

+

+  /**

+   * DOM Implementation.

+   */

+  private static String DOM_LS_3_0 = "LS 3.0";

+  

+  private static DOMImplementationLS domImplLS;

+  

+  private DOMUtils() {

+  }

+  

+  private static synchronized void ensureDOMImplementation() {

+    

+    if (domImplLS == null) {

+

+      DOMImplementationRegistry registry;

+      try {

+        registry = DOMImplementationRegistry.newInstance();

+      } catch (Exception e) {

+        throw new RuntimeException("Failed to get DOMImplementationRegistry.");

+      }

+

+      domImplLS = (DOMImplementationLS) registry.getDOMImplementation(DOM_LS_3_0);

+      if (domImplLS == null) {

+        throw new RuntimeException("Failed to get DOMImplementation " + DOM_LS_3_0);

+      }

+      

+    }

+    

+  }

+

+  public static DOMImplementationLS getDOMImplementationLS() {

+    

+    if (domImplLS == null) {

+      ensureDOMImplementation();

+    }

+    

+    return domImplLS;

+  }

+  

+  public static Document createDocument() {

+    

+    // This does not work with the Xerces-J version (2.6.2) included in Java 6

+    //document = ((DOMImplementation) domImplLS).createDocument(null, null, null);

+    // Therefore we have to employ the good old DocumentBuilderFactory

+    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

+    DocumentBuilder db;

+    try {

+      db = dbf.newDocumentBuilder();

+    } catch (ParserConfigurationException e) {

+      throw new RuntimeException(e);

+    }

+    return db.newDocument();

+       

+  }

+  

+  public static Text createBase64Text(byte[] bytes, Document doc) throws IOException {

+    

+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

+    Base64OutputStream base64OutputStream = new Base64OutputStream(outputStream);

+    base64OutputStream.write(bytes);

+    base64OutputStream.flush();

+    return doc.createTextNode(outputStream.toString("ASCII"));

+    

+  }

+  

+  public static Text createBase64Text(InputStream bytes, Document doc) throws IOException {

+    

+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

+    Base64OutputStream base64OutputStream = new Base64OutputStream(outputStream, new byte[] {0xa});

+

+    byte[] b = new byte[2^8];

+    for(int l; (l = bytes.read(b)) != -1;) {

+      base64OutputStream.write(b, 0, l);

+    }

+    

+    base64OutputStream.flush();

+    return doc.createTextNode(outputStream.toString("ASCII"));

+  }

+

+}

diff --git a/utils/src/main/java/at/gv/egiz/idlink/CompressedIdentityLinkFactory.java b/utils/src/main/java/at/gv/egiz/idlink/CompressedIdentityLinkFactory.java
new file mode 100644
index 00000000..5f4e5d92
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/idlink/CompressedIdentityLinkFactory.java
@@ -0,0 +1,416 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.idlink;

+

+import java.io.BufferedReader;

+import java.io.ByteArrayInputStream;

+import java.io.IOException;

+import java.io.InputStreamReader;

+import java.security.PublicKey;

+import java.security.cert.X509Certificate;

+import java.util.List;

+

+import javax.xml.bind.JAXBContext;

+import javax.xml.bind.JAXBElement;

+import javax.xml.bind.JAXBException;

+import javax.xml.bind.Marshaller;

+import javax.xml.bind.PropertyException;

+import javax.xml.bind.Unmarshaller;

+import javax.xml.transform.Source;

+import javax.xml.transform.dom.DOMResult;

+

+import org.w3._2000._09.xmldsig_.KeyValueType;

+import org.w3c.dom.Attr;

+import org.w3c.dom.Document;

+import org.w3c.dom.Element;

+import org.w3c.dom.Node;

+import org.w3c.dom.NodeList;

+

+import at.buergerkarte.namespaces.personenbindung._20020506_.CompressedIdentityLinkType;

+import at.gv.e_government.reference.namespace.persondata._20020228_.AbstractPersonType;

+import at.gv.e_government.reference.namespace.persondata._20020228_.IdentificationType;

+import at.gv.e_government.reference.namespace.persondata._20020228_.PersonNameType;

+import at.gv.e_government.reference.namespace.persondata._20020228_.PhysicalPersonType;

+import at.gv.e_government.reference.namespace.persondata._20020228_.IdentificationType.Value;

+import at.gv.e_government.reference.namespace.persondata._20020228_.PersonNameType.FamilyName;

+import at.gv.egiz.idlink.ans1.CitizenPublicKey;

+import at.gv.egiz.idlink.ans1.IdentityLink;

+import at.gv.egiz.idlink.ans1.PersonData;

+import at.gv.egiz.idlink.ans1.PhysicalPersonData;

+import at.gv.egiz.xmldsig.KeyTypeNotSupportedException;

+import at.gv.egiz.xmldsig.KeyValueFactory;

+

+public class CompressedIdentityLinkFactory {

+  

+  /**

+   * The instance returned by {@link #getInstance()}.

+   */

+  private static CompressedIdentityLinkFactory instance;

+  

+  /**

+   * The <code>JAXBContext</code>.

+   */

+  private static JAXBContext jaxbContext;

+  

+  /**

+   * The <code>KeyValueFactory</code>.

+   */

+  private static KeyValueFactory keyValueFactory;

+  

+  /**

+   * Get an instance of this <code>CompressedIdentityLinkFactory</code>.

+   * 

+   * @return an instance of this <code>CompressedIdentityLinkFactory</code>

+   */

+  public synchronized static CompressedIdentityLinkFactory getInstance() {

+    if (instance == null) {

+      instance = new CompressedIdentityLinkFactory();

+    }

+    return instance;

+  }

+

+  /**

+   * Private constructor.

+   */

+  private CompressedIdentityLinkFactory() {

+    

+    keyValueFactory = new KeyValueFactory();

+

+    StringBuffer packageNames = new StringBuffer();

+    packageNames.append(at.gv.e_government.reference.namespace.persondata._20020228_.ObjectFactory.class.getPackage().getName());

+    packageNames.append(":");

+    packageNames.append(org.w3._2000._09.xmldsig_.ObjectFactory.class.getPackage().getName());

+    packageNames.append(":");

+    packageNames.append(org.w3._2001._04.xmldsig_more_.ObjectFactory.class.getPackage().getName());

+    packageNames.append(":");

+    packageNames.append(at.buergerkarte.namespaces.personenbindung._20020506_.ObjectFactory.class.getPackage().getName());

+

+    try {

+      jaxbContext = JAXBContext.newInstance(packageNames.toString());

+    } catch (JAXBException e) {

+      // we should not get an JAXBException initializing the JAXBContext

+      throw new RuntimeException(e);

+    }

+  

+  }

+  

+  public IdentityLink createIdLink(CompressedIdentityLinkType compressedIdentityLinkType) {

+    

+    // IssuerTemplate

+    String issuerTemplate = compressedIdentityLinkType.getIssuerTemplate();

+    

+    // AssertionId

+    String assertionID = compressedIdentityLinkType.getAssertionID();

+    

+    // IssueInstant

+    String issueInstant = compressedIdentityLinkType.getIssueInstant();

+    

+    AbstractPersonType personDataType = compressedIdentityLinkType.getPersonData();

+

+    String baseId = null;

+

+    List<IdentificationType> identifications = personDataType.getIdentification();

+    for (IdentificationType identificationType : identifications) {

+      String type = identificationType.getType();

+      if ("urn:publicid:gv.at:baseid".equals(type)) {

+        baseId = identificationType.getValue().getValue();

+      }

+    }

+

+    String givenName = null;

+    String familyName = null;

+    String dateOfBirth = null;

+    

+    if (personDataType instanceof PhysicalPersonType) {

+      PhysicalPersonType physicalPersonType = (PhysicalPersonType) personDataType;

+      PersonNameType name = physicalPersonType.getName();

+      List<String> givenNames = name.getGivenName();

+      if (!givenNames.isEmpty()) {

+        givenName = givenNames.get(0);

+      }

+      List<FamilyName> familyNames = name.getFamilyName();

+      if (!familyNames.isEmpty()) {

+        familyName = familyNames.get(0).getValue();

+      }

+      dateOfBirth = physicalPersonType.getDateOfBirth();

+    }

+    

+    PhysicalPersonData physicalPersonData = new PhysicalPersonData(baseId, givenName, familyName, dateOfBirth);

+    PersonData personData = new PersonData(physicalPersonData);

+

+    int numKeys = compressedIdentityLinkType.getCitizenPublicKey().size();

+    CitizenPublicKey[] citizenPublicKeys = new CitizenPublicKey[numKeys];

+    for (int i = 0; i < numKeys;) {

+      citizenPublicKeys[i] = new CitizenPublicKey(++i); 

+    }

+    

+    byte[] signatureValue = compressedIdentityLinkType.getSignatureValue();

+    byte[] referenceDigest = compressedIdentityLinkType.getReferenceDigest();

+    byte[] referenceManifestDigest = compressedIdentityLinkType.getReferenceManifestDigest();

+    byte[] manifestReferenceDigest = compressedIdentityLinkType.getManifestReferenceDigest();

+    

+    IdentityLink idLink = new IdentityLink(issuerTemplate, assertionID, issueInstant, personData, citizenPublicKeys, signatureValue);

+    idLink.setReferenceDigest(referenceDigest);

+    idLink.setReferenceManifestDigest(referenceManifestDigest);

+    idLink.setManifestReferenceDigest(manifestReferenceDigest);

+    

+    return idLink;

+    

+  }

+  

+  /**

+   * Creates a new <code>CompressedIdentityLink</code> element from the given

+   * ASN.1 representation of an <code>idLink</code>.

+   * 

+   * @param idLink

+   *          the ASN.1 representation of an <code>IdentityLink</code>

+   * @param certificates

+   *          a list of {@link X509Certificate}s containing the corresponding

+   *          public keys

+   * @param domainId TODO

+   * @return a new <code>CompressedIdentityLink</code> element

+   * 

+   * @throws NullPointerException

+   *           if <code>idLink</code> or <code>certificates</code> is

+   *           <code>null</code>

+   * @throws IllegalArgumentException

+   *           if <code>idLink</code> references certificates not in the range

+   *           of the <code>certificates</code> list

+   */

+  public JAXBElement<CompressedIdentityLinkType> createCompressedIdentityLink(

+      at.gv.egiz.idlink.ans1.IdentityLink idLink,

+      List<X509Certificate> certificates, String domainId) {

+

+    at.gv.e_government.reference.namespace.persondata._20020228_.ObjectFactory prFactory = 

+      new at.gv.e_government.reference.namespace.persondata._20020228_.ObjectFactory();

+

+    at.buergerkarte.namespaces.personenbindung._20020506_.ObjectFactory pbFactory = 

+      new at.buergerkarte.namespaces.personenbindung._20020506_.ObjectFactory();

+

+    org.w3._2000._09.xmldsig_.ObjectFactory dsFactory = new org.w3._2000._09.xmldsig_.ObjectFactory();

+

+    // PersonData

+    PhysicalPersonData __physicalPersonData = idLink.getPersonData()

+        .getPhysicalPerson();

+

+    Value identificationTypeValue = prFactory.createIdentificationTypeValue();

+    identificationTypeValue.setValue(__physicalPersonData.getBaseId());

+    IdentificationType identificationType = prFactory

+        .createIdentificationType();

+    identificationType.setValue(identificationTypeValue);

+    if (domainId != null) {

+      identificationType.setType(domainId);

+    } else {

+      identificationType.setType("urn:publicid:gv.at:baseid");

+    }

+

+    PersonNameType personNameType = prFactory.createPersonNameType();

+    FamilyName personNameTypeFamilyName = prFactory

+        .createPersonNameTypeFamilyName();

+    personNameTypeFamilyName.setValue(__physicalPersonData.getFamilyName());

+    personNameType.getFamilyName().add(personNameTypeFamilyName);

+    personNameType.getGivenName().add(__physicalPersonData.getGivenName());

+

+    PhysicalPersonType physicalPersonType = prFactory

+        .createPhysicalPersonType();

+    physicalPersonType.getIdentification().add(identificationType);

+    physicalPersonType.setName(personNameType);

+    physicalPersonType.setDateOfBirth(__physicalPersonData.getDateOfBirth());

+

+    // CompressedIdentityLink

+    CompressedIdentityLinkType compressedIdentityLinkType = pbFactory

+        .createCompressedIdentityLinkType();

+    compressedIdentityLinkType.setIssuerTemplate(idLink.getIssuerTemplate());

+    compressedIdentityLinkType.setAssertionID(idLink.getAssertionID());

+    compressedIdentityLinkType.setIssueInstant(idLink.getIssueInstant());

+    compressedIdentityLinkType.setPersonData(physicalPersonType);

+

+    // CitizenPublicKey

+    CitizenPublicKey[] __citizenPublicKeys = idLink.getCitizenPublicKeys();

+    for (CitizenPublicKey __citizenPublicKey : __citizenPublicKeys) {

+

+      X509Certificate certificate = certificates.get(__citizenPublicKey.getOnToken());

+      PublicKey publicKey = certificate.getPublicKey();

+      

+      JAXBElement<?> keyValue;

+      try {

+        keyValue = keyValueFactory.createKeyValue(publicKey);

+      } catch (KeyTypeNotSupportedException e) {

+        // TODO: handle exception properly

+        throw new RuntimeException(e);

+      }

+

+      KeyValueType keyValueType = dsFactory.createKeyValueType();

+      keyValueType.getContent().add(keyValue);

+      

+      compressedIdentityLinkType.getCitizenPublicKey().add(keyValueType);

+    }

+

+    compressedIdentityLinkType.setSignatureValue(idLink.getSignatureValue());

+    compressedIdentityLinkType.setReferenceDigest(idLink.getReferenceDigest());

+    compressedIdentityLinkType.setReferenceManifestDigest(idLink

+        .getReferenceManifestDigest());

+    compressedIdentityLinkType.setManifestReferenceDigest(idLink

+        .getManifestReferenceDigest());

+    JAXBElement<CompressedIdentityLinkType> compressedIdentityLink = pbFactory

+        .createCompressedIdentityLink(compressedIdentityLinkType);

+

+    return compressedIdentityLink;

+

+  }

+

+  /**

+   * Marshall the given <code>compressedIdentityLink</code> into a DOM document

+   * with the given Nodes as <code>parent</code> and <code>nextSibling</code>

+   * nodes.

+   * 

+   * @param compressedIdentityLink

+   *          the <code>CompressedIdentityLink</code> element

+   * @param parent

+   *          the parent node

+   * @param nextSibling

+   *          the next sibling node (may be <code>null</code>)

+   * @param applyWorkarounds

+   *          apply workarounds as spefiyed by

+   *          {@link #applyWorkarounds(Element, int)}

+   * 

+   * @throws JAXBException

+   *           if an unexpected error occurs while marshalling

+   * @throws NullPointerException

+   *           if <code>compressdIdentityLink</code> or <code>parent</code> is

+   *           <code>null</code>

+   */

+  public void marshallCompressedIdentityLink(

+      JAXBElement<CompressedIdentityLinkType> compressedIdentityLink,

+      Node parent, Node nextSibling, boolean applyWorkarounds) throws JAXBException {

+    

+    DOMResult result = new DOMResult(parent, nextSibling);

+    

+

+    try {

+      Marshaller marshaller = jaxbContext.createMarshaller();

+

+      marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

+

+      marshaller.marshal(compressedIdentityLink, result);

+    } catch (PropertyException e) {

+      throw new RuntimeException(e);

+    } 

+  

+    if (applyWorkarounds) {

+      Element element = (Element) ((nextSibling != null) 

+          ? nextSibling.getPreviousSibling() 

+          : parent.getFirstChild());

+      applyWorkarounds(element, 76);

+    }

+    

+  }

+  

+  @SuppressWarnings("unchecked")

+  public CompressedIdentityLinkType unmarshallCompressedIdentityLink(Source source) throws JAXBException {

+    

+    Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();

+    

+    return ((JAXBElement<CompressedIdentityLinkType>) unmarshaller.unmarshal(source)).getValue();

+    

+  }

+  

+  /**

+   * Apply some workarounds to the given CompressedIdentityLink

+   * <code>element</code> to achieve compatibility with IdentityLink

+   * transformation stylesheets that have been designed for a (buggy) form of

+   * the CompressedIdentityLink as produced by a well-known citizen card

+   * environment implementation.

+   * 

+   * <ol>

+   * <li>Replace the attribute node <code>URN</code> of the

+   * <code>NamedCurve</code> element of an <code>ECDSAKeyValue</code> element by

+   * a child text-node with the same content.</li>

+   * <li>Replace the attribute nodes <code>Value</code> of the <code>X</code>

+   * and <code>Y</code> elements of an <code>ECDSAKeyValue</code> element by a

+   * child text-node with the same content.</li>

+   * <li>Insert &quot;\n&quot; at <code>base64LineLength</code> into the Base64

+   * content of the <code>Modulus</code> element of an <code>RSAKeyValue</code>

+   * element.

+   * </ol>

+   * 

+   * @param element

+   *          the <code>CompressedIdentityLink</code> element

+   * @param base64LineLength

+   *          the line length of Base64 content

+   */

+  public void applyWorkarounds(Element element, int base64LineLength) {

+    

+    Document document = element.getOwnerDocument();

+    

+    NodeList nodeList = element.getElementsByTagNameNS(

+        "http://www.w3.org/2001/04/xmldsig-more#", "NamedCurve");

+    for (int i = 0; i < nodeList.getLength(); i++) {

+      Node ecdsaNameCurve = nodeList.item(i);

+      Attr attrNode = ((Element) ecdsaNameCurve).getAttributeNodeNS(null,

+          "URN");

+      ecdsaNameCurve

+          .appendChild(document.createTextNode(attrNode.getValue()));

+      ((Element) ecdsaNameCurve).removeAttributeNode(attrNode);

+    }

+    nodeList = document.getElementsByTagNameNS(

+        "http://www.w3.org/2001/04/xmldsig-more#", "X");

+    for (int i = 0; i < nodeList.getLength(); i++) {

+      Node x = nodeList.item(i);

+      Attr attrNode = ((Element) x).getAttributeNodeNS(null, "Value");

+      x.appendChild(document.createTextNode(attrNode.getValue()));

+      ((Element) x).removeAttributeNode(attrNode);

+    }

+    nodeList = document.getElementsByTagNameNS(

+        "http://www.w3.org/2001/04/xmldsig-more#", "Y");

+    for (int i = 0; i < nodeList.getLength(); i++) {

+      Node y = nodeList.item(i);

+      Attr attrNode = ((Element) y).getAttributeNodeNS(null, "Value");

+      y.appendChild(document.createTextNode(attrNode.getValue()));

+      ((Element) y).removeAttributeNode(attrNode);

+    }

+

+    if (base64LineLength > 0) {

+      nodeList = document.getElementsByTagNameNS(

+          "http://www.w3.org/2000/09/xmldsig#", "Modulus");

+      for (int i = 0; i < nodeList.getLength(); i++) {

+        Node modulus = nodeList.item(i);

+        String value = ((Element) modulus).getTextContent();

+        BufferedReader reader = new BufferedReader(new InputStreamReader(

+            new ByteArrayInputStream(value.getBytes())));

+        char[] buff = new char[base64LineLength];

+        StringBuffer newValue = new StringBuffer();

+        int found = 0;

+        try {

+          while ((found = reader.read(buff)) > 0) {

+            newValue.append(buff, 0, found);

+            if (found == base64LineLength)

+              newValue.append('\n');

+          }

+        } catch (IOException e) {

+          // this should never happen, as we are reading from a ByteArrayInputStream

+          throw new RuntimeException(e);

+        }

+        ((Element) modulus).setTextContent(newValue.toString());

+      }

+

+    }

+

+    

+  }

+  

+}

diff --git a/utils/src/main/java/at/gv/egiz/idlink/IdentityLinkTransformer.java b/utils/src/main/java/at/gv/egiz/idlink/IdentityLinkTransformer.java
new file mode 100644
index 00000000..7886b07d
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/idlink/IdentityLinkTransformer.java
@@ -0,0 +1,285 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.idlink;

+

+import java.io.IOException;

+import java.net.MalformedURLException;

+import java.net.URL;

+import java.util.ArrayList;

+import java.util.Date;

+import java.util.HashMap;

+import java.util.Iterator;

+import java.util.List;

+import java.util.Map;

+

+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.stream.StreamSource;

+

+import org.w3c.dom.Document;

+import org.w3c.dom.Element;

+import org.w3c.dom.Node;

+import org.w3c.dom.NodeList;

+import org.w3c.dom.Text;

+

+public class IdentityLinkTransformer {

+

+  private class IdLTransformer {

+    

+    /**

+     * Is transformer in use?

+     */

+    private boolean inUse = false;

+    

+    /**

+     * How often has this transformer been used?

+     */

+    private int timesUsed = 0;

+    

+    /**

+     * The time this transformer has been created.

+     */

+    private long created;

+    

+    /**

+     * When has this transformer been used the last time?

+     */

+    private long lastTimeUsed;

+    

+    /**

+     * Average performance in milliseconds. 

+     */

+    private long time;

+    

+    /**

+     * Time used for initialization.

+     */

+    private long initTime;

+    

+    /**

+     * The stylesheet transformer.

+     */

+    private Transformer transformer;

+    

+    /**

+     * Stylesheet URL.

+     */

+    private String stylesheetURL;

+

+    /**

+     * 

+     * @param stylesheetURL

+     * @throws IOException

+     * @throws TransformerConfigurationException

+     */

+    public IdLTransformer(String stylesheetURL) throws IOException, TransformerConfigurationException {

+      

+      created = System.currentTimeMillis();

+      

+      // TODO: implement stylesheet cache

+      this.stylesheetURL = stylesheetURL;

+      URL url = new URL(stylesheetURL);

+

+      if (!"http".equalsIgnoreCase(url.getProtocol()) && !"https".equalsIgnoreCase(url.getProtocol())) {

+        throw new MalformedURLException("Protocol " + url.getProtocol() + " not supported for IssuerTemplate URL.");

+      }

+      StreamSource source = new StreamSource(url.openStream());

+      

+      transformer = factory.newTransformer(source);

+

+      initTime = System.currentTimeMillis() - created;

+      

+    }

+    

+    public void transform(Source xmlSource, Result outputTarget) throws TransformerException {

+      long t0 = System.currentTimeMillis();

+      try {

+        transformer.transform(xmlSource, outputTarget);

+      } catch (TransformerException e) {

+        throw e;

+      } finally {

+        inUse = false;

+        long t1 = System.currentTimeMillis();

+        time += (t1 - t0);

+        timesUsed++;

+        lastTimeUsed = System.currentTimeMillis();

+      }

+    }

+    

+    /**

+     * @return <code>true</code> if this transformer is in use, or <code>false</code> otherwise

+     */

+    public boolean isInUse() {

+      return inUse;

+    }

+

+    @Override

+    public String toString() {

+      StringBuffer str = new StringBuffer();

+      str.append("Transformer ").append(stylesheetURL)

+        .append("\n    created ").append(new Date(created)).append(" used ").append(

+          timesUsed).append(" times, (init ").append(initTime).append("ms / ")

+        .append(((float) time) / timesUsed).append("ms avg) last time ").append(new Date(lastTimeUsed));

+      return str.toString();

+    }

+    

+  }

+  

+  /**

+   * The transfomer factory.

+   */

+  private static TransformerFactory factory;

+

+  /**

+   * The instance to be returned by {@link #getInstance()}.

+   */

+  private static IdentityLinkTransformer instance;

+  

+  /**

+   * Returns an instance of this <code>IdentityLinkTransfomer</code>.

+   * 

+   * @return an instance of this <code>IdentityLinkTransformer</code>

+   */

+  public static IdentityLinkTransformer getInstance() {

+    if (instance == null) {

+      instance = new IdentityLinkTransformer();

+      factory = TransformerFactory.newInstance();

+    }

+    return instance;

+  }

+

+  /**

+   * Sets the given <code>domainIdentifier</code> on the corresponding

+   * node of the given <code>idLink</code>.

+   * <p>This method may be used to cope with a flaw in the IssuerTemplate-Stylesheets

+   * used to transform a <code>CompressedIdentitiyLink</code> into an

+   * <code>IdentityLink</code>. Some IssuerTemplate-Stylesheets do not

+   * consider the <code>pr:Type</code> element value of the 

+   * <code>CompressedIdentityLink</code> and render a <code>pr:Type</code> 

+   * element value of <code>urn:publicid:gv.at:baseid</code>

+   * into the <code>IdentityLink</code> structure. This method allows to

+   * set the <code>pr:Type</code> element value on the given <code>idLink</code>

+   * after the transformation.

+   * </p>

+   * 

+   * @param idLink the <code>IdentityLink</code> element or one of it's ancestors.

+   * Must not be <code>null</code>.

+   * 

+   * @param domainIdentifier the value to be set for the <code>pr:Type</code> element

+   * 

+   * @throws NullPointerException if <code>idLink</code> is <code>null</code>.

+   */

+  public static void setDomainIdentifier(Node idLink, String domainIdentifier) {

+    

+    Element element;

+    if (idLink instanceof Element) {

+      element = (Element) idLink;

+    } else if (idLink instanceof Document) {

+      element = ((Document) idLink).getDocumentElement();

+    } else if (idLink != null) {

+      Document document = idLink.getOwnerDocument();

+      element = document.getDocumentElement();

+    } else {

+      throw new NullPointerException("Parameter 'idLink' must no be null.");

+    }

+    

+    NodeList nodeList = element.getElementsByTagNameNS(

+        "http://reference.e-government.gv.at/namespace/persondata/20020228#",

+        "Type");

+

+    for (int i = 0; i < nodeList.getLength(); i++) {

+      if (nodeList.item(i) instanceof Element) {

+        Element typeElement = (Element) nodeList.item(i);

+        NodeList children = typeElement.getChildNodes();

+        for (int j = 0; j < children.getLength(); j++) {

+          if (children.item(j) instanceof Text) {

+            ((Text) children.item(j)).setNodeValue(domainIdentifier);

+          }

+        }

+      }

+    }

+    

+  }

+  

+  /**

+   * The pool of <code>Transformer</code>.

+   */

+  private Map<String, List<IdLTransformer>> pool;

+  

+  /**

+   * Private constructor.

+   */

+  private IdentityLinkTransformer() {

+    pool = new HashMap<String, List<IdLTransformer>>();

+  }

+  

+  private synchronized IdLTransformer getFreeTransfomer(String stylesheetURL) throws TransformerConfigurationException, IOException {

+    

+    IdLTransformer transformer = null;

+    

+    List<IdLTransformer> transfomerList = pool.get(stylesheetURL);

+    if (transfomerList == null) {

+      transfomerList = new ArrayList<IdLTransformer>();

+      pool.put(stylesheetURL, transfomerList);

+    }

+    

+    for (IdLTransformer candTransformer : transfomerList) {

+      if (!candTransformer.inUse) {

+        transformer = candTransformer;

+        break;

+      }

+    }

+    

+    if (transformer == null) {

+      transformer = new IdLTransformer(stylesheetURL);

+      transfomerList.add(transformer);

+    }

+    

+    transformer.inUse = true;

+    return transformer;

+    

+  }

+  

+  public void transformIdLink(String stylesheetURL, Source source, Result result) throws IOException, TransformerException {

+    IdLTransformer transformer = getFreeTransfomer(stylesheetURL);

+    transformer.transform(source, result);

+  }

+  

+  public String getStatistics() {

+    

+    StringBuffer str = new StringBuffer();

+    Iterator<String> keys = pool.keySet().iterator();

+    int count = 0;

+    while (keys.hasNext()) {

+      String stylesheetURL = (String) keys.next();

+      str.append("Stylesheet URL: ").append(stylesheetURL);

+      Iterator<IdLTransformer> transformer = pool.get(stylesheetURL).iterator();

+      while (transformer.hasNext()) {

+        IdLTransformer idLTransformer = (IdLTransformer) transformer.next();

+        str.append("\n  ").append(idLTransformer);

+        count++;

+      }

+    }

+    str.append("\n(").append(count).append(" transformer)");

+    return str.toString();

+  }

+  

+}

diff --git a/utils/src/main/java/at/gv/egiz/idlink/ans1/CitizenPublicKey.java b/utils/src/main/java/at/gv/egiz/idlink/ans1/CitizenPublicKey.java
new file mode 100644
index 00000000..c32cf2b9
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/idlink/ans1/CitizenPublicKey.java
@@ -0,0 +1,92 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.idlink.ans1;
+
+import java.math.BigInteger;
+
+import iaik.asn1.*;
+
+/**
+ * This class implements the ASN.1 representation of the 
+ * <code>CitizenPublicKey</code> of a compressed identity link.
+ * 
+ * <pre>CitizenPublicKey ::= CHOICE { 
+    onToken [0] INTEGER, 
+    referenceURL [1] UTF8String, 
+    x509Data [2] SubjectPublicKeyInfo 
+}  
+</pre>
+ * 
+ * @author mivkovic@egiz.gv.at, mcentner@egiz.gv.at
+ */
+public class CitizenPublicKey implements ASN1Type {
+
+  /**
+   * <code>onToken</code>
+   */
+  private int onToken; // INTEGER
+
+  /**
+   * Creates a new <code>CitizenPublicKey</code> with the given 
+   * <code>onToken</code> value.
+   * 
+   * @param onToken
+   */
+  public CitizenPublicKey(int onToken) {
+    this.onToken = onToken;
+  }
+
+  /**
+   * Creates a new <code>CitizenPublicKey</code> from the given ASN.1 representation.
+   * 
+   * @param obj
+   * @throws CodingException
+   */
+  public CitizenPublicKey(ASN1Object obj) throws CodingException {
+    decode(obj);
+  }
+
+  @Override
+  public void decode(ASN1Object obj) throws CodingException {
+    try {
+       BigInteger Value = (BigInteger)(obj.getValue());
+       onToken = Value.intValue();
+    } catch (Exception ex) {
+      throw new CodingException(ex.toString());
+    }
+  }
+
+  @Override
+  public ASN1Object toASN1Object() {
+    INTEGER ot = new INTEGER(onToken);
+    return ot;
+  }
+
+  /**
+   * Returns the DER encoding of this <code>CitizenPublicKey</code>.
+   * 
+   * @return the DER encoding of this <code>CitizenPublicKey</code>
+   */
+  public byte[] getEncoded() {
+    return DerCoder.encode(toASN1Object());
+  }
+
+  public int getOnToken() {
+    return onToken;
+  }
+
+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/idlink/ans1/IdentityLink.java b/utils/src/main/java/at/gv/egiz/idlink/ans1/IdentityLink.java
new file mode 100644
index 00000000..37e4b240
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/idlink/ans1/IdentityLink.java
@@ -0,0 +1,315 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.idlink.ans1;

+

+import iaik.asn1.ASN1Object;

+import iaik.asn1.ASN1Type;

+import iaik.asn1.BIT_STRING;

+import iaik.asn1.CON_SPEC;

+import iaik.asn1.CodingException;

+import iaik.asn1.DerCoder;

+import iaik.asn1.INTEGER;

+import iaik.asn1.SEQUENCE;

+import iaik.asn1.UTF8String;

+

+/**

+ * This class impelments an ASN.1 representation of the compressed <code>IdentiyLink</code>.

+ * <pre>

+PersonenBindung ::= SEQUENCE { 

+    version INTEGER, 

+    issuerTemplate UTF8String, 

+    assertionID UTF8String, 

+    issueInstant UTF8String, 

+    personData PersonData, 

+    citizenPublicKey SEQUENCE SIZE (1..MAX) OF CitizenPublicKey, 

+    signatureValue BIT STRING, 

+    referenceDigest [0] BIT STRING OPTIONAL, 

+    referenceManifestDigest [1] BIT STRING OPTIONAL, 

+    manifestReferenceDigest [2] BIT STRING OPTIONAL 

+} 

+</pre>

+ * 

+ * @author mivkovic@egiz.gv.at, mcentner@egiz.gv.at

+ */

+public class IdentityLink implements ASN1Type {

+

+  private int version = 1; // INTEGER

+  private String issuerTemplate; // UTF8String

+  private String assertionID; // UTF8String

+  private String issueInstant; // UTF8String

+  private PersonData personData; // PersonData

+  private CitizenPublicKey[] citizenPublicKeys; // SEQUENCE SIZE (1..MAX) OF

+  private byte[] signatureValue; // BIT STRING

+  private byte[] referenceDigest; // BIT STRING OPTIONAL

+  private byte[] referenceManifestDigest; // BIT STRING OPTIONAL

+  private byte[] manifestReferenceDigest; // BIT STRING OPTIONAL

+

+  /**

+   * Creates a new <code>IdentityLink</code> with the given

+   * <code>issuerTemplate</code>, <code>assertionID</code>,

+   * <code>issueInstant</code>, <code>personData</code>,

+   * <code>citizenPublicKeys</code> and <code>signatureValue</code>.

+   * 

+   * @param issuerTemplate

+   * @param assertionID

+   * @param issueInstant

+   * @param personData

+   * @param citizenPublicKeys

+   * @param signatureValue

+   */

+  public IdentityLink(String issuerTemplate, String assertionID,

+      String issueInstant, PersonData personData,

+      CitizenPublicKey[] citizenPublicKeys, byte[] signatureValue) {

+    this.issuerTemplate = issuerTemplate;

+    this.assertionID = assertionID;

+    this.issueInstant = issueInstant;

+    this.personData = personData;

+    this.citizenPublicKeys = citizenPublicKeys;

+    this.signatureValue = signatureValue;

+  }

+  

+  /**

+   * Create a new IdentityLink from an ASN1Object.

+   * 

+   * @param identiyLink

+   * @throws CodingException

+   */

+  public IdentityLink(ASN1Object identiyLink) throws CodingException {

+    decode(identiyLink);

+  }

+  

+  @Override

+  public void decode(ASN1Object obj) throws CodingException {

+    issuerTemplate = (String) ((ASN1Object) obj.getComponentAt(1)).getValue();

+    assertionID = (String) ((ASN1Object) obj.getComponentAt(2)).getValue();

+    issueInstant = (String) ((ASN1Object) obj.getComponentAt(3)).getValue();

+

+    if (((CON_SPEC) obj.getComponentAt(4)).getAsnType().getTag() == 0)

+      personData = new PersonData((ASN1Object) obj.getComponentAt(4).getValue());

+    else {

+      throw new CodingException("CorporateBodyData currently not supported.");

+    }

+

+    SEQUENCE publicKeySequence = (SEQUENCE) obj.getComponentAt(5);

+    int anz = publicKeySequence.countComponents();

+    citizenPublicKeys = new CitizenPublicKey[anz];

+    for (int i = 0; i < citizenPublicKeys.length; i++) {

+      CON_SPEC tmp = (CON_SPEC) publicKeySequence.getComponentAt(i);

+      if (tmp.getAsnType().getTag() == 0) {

+        citizenPublicKeys[i] = new CitizenPublicKey((ASN1Object) tmp.getValue());

+      } else {

+        throw new CodingException(

+            "Currently only PublicKeys on token are supported.");

+      }

+    }

+

+    signatureValue = (byte[]) ((ASN1Object) obj.getComponentAt(6)).getValue();

+

+    for (int i = 7; i < obj.countComponents(); i++) {

+      CON_SPEC tmp = (CON_SPEC) obj.getComponentAt(i);

+      switch (tmp.getAsnType().getTag()) {

+      case 0:

+        referenceDigest = (byte[]) ((BIT_STRING) tmp.getValue()).getValue();

+        break;

+      case 1:

+        referenceManifestDigest = (byte[]) ((BIT_STRING) tmp.getValue())

+            .getValue();

+        break;

+      case 2:

+        manifestReferenceDigest = (byte[]) ((BIT_STRING) tmp.getValue())

+            .getValue();

+        break;

+      }

+

+    }

+

+  }

+

+  @Override

+  public ASN1Object toASN1Object() {

+    SEQUENCE pb = new SEQUENCE();

+    pb.addComponent(new INTEGER(version));

+    pb.addComponent(new UTF8String(issuerTemplate));

+    pb.addComponent(new UTF8String(assertionID));

+    pb.addComponent(new UTF8String(issueInstant));

+

+    pb.addComponent(new CON_SPEC(0, personData.toASN1Object()));

+    SEQUENCE seq = new SEQUENCE();

+    for (int i = 0; i < citizenPublicKeys.length; i++) {

+      seq.addComponent(new CON_SPEC(0, citizenPublicKeys[i].toASN1Object()));

+    }

+    pb.addComponent(seq);

+    pb.addComponent(new BIT_STRING(signatureValue));

+    if (referenceDigest != null)

+      pb.addComponent(new CON_SPEC(0, new BIT_STRING(referenceDigest)));

+    if (referenceManifestDigest != null)

+      pb.addComponent(new CON_SPEC(1, new BIT_STRING(referenceManifestDigest)));

+    if (manifestReferenceDigest != null)

+      pb.addComponent(new CON_SPEC(2, new BIT_STRING(manifestReferenceDigest)));

+    return pb;

+  }

+

+  /**

+   * Returns the DER encoding of this <code>IdentityLink</code>.

+   * 

+   * @return the DER encoding of this <code>IdentityLink</code>

+   */

+  public byte[] toByteArray() {

+    return DerCoder.encode(toASN1Object());

+  }

+

+  /**

+   * @return the version

+   */

+  public int getVersion() {

+    return version;

+  }

+

+  /**

+   * @param version the version to set

+   */

+  public void setVersion(int version) {

+    this.version = version;

+  }

+

+  /**

+   * @return the issuerTemplate

+   */

+  public String getIssuerTemplate() {

+    return issuerTemplate;

+  }

+

+  /**

+   * @param issuerTemplate the issuerTemplate to set

+   */

+  public void setIssuerTemplate(String issuerTemplate) {

+    this.issuerTemplate = issuerTemplate;

+  }

+

+  /**

+   * @return the assertionID

+   */

+  public String getAssertionID() {

+    return assertionID;

+  }

+

+  /**

+   * @param assertionID the assertionID to set

+   */

+  public void setAssertionID(String assertionID) {

+    this.assertionID = assertionID;

+  }

+

+  /**

+   * @return the issueInstant

+   */

+  public String getIssueInstant() {

+    return issueInstant;

+  }

+

+  /**

+   * @param issueInstant the issueInstant to set

+   */

+  public void setIssueInstant(String issueInstant) {

+    this.issueInstant = issueInstant;

+  }

+

+  /**

+   * @return the personData

+   */

+  public PersonData getPersonData() {

+    return personData;

+  }

+

+  /**

+   * @param personData the personData to set

+   */

+  public void setPersonData(PersonData personData) {

+    this.personData = personData;

+  }

+

+  /**

+   * @return the citizenPublicKeys

+   */

+  public CitizenPublicKey[] getCitizenPublicKeys() {

+    return citizenPublicKeys;

+  }

+

+  /**

+   * @param citizenPublicKeys the citizenPublicKeys to set

+   */

+  public void setCitizenPublicKeys(CitizenPublicKey[] citizenPublicKeys) {

+    this.citizenPublicKeys = citizenPublicKeys;

+  }

+

+  /**

+   * @return the signatureValue

+   */

+  public byte[] getSignatureValue() {

+    return signatureValue;

+  }

+

+  /**

+   * @param signatureValue the signatureValue to set

+   */

+  public void setSignatureValue(byte[] signatureValue) {

+    this.signatureValue = signatureValue;

+  }

+

+  /**

+   * @return the referenceDigest

+   */

+  public byte[] getReferenceDigest() {

+    return referenceDigest;

+  }

+

+  /**

+   * @param referenceDigest the referenceDigest to set

+   */

+  public void setReferenceDigest(byte[] referenceDigest) {

+    this.referenceDigest = referenceDigest;

+  }

+

+  /**

+   * @return the referenceManifestDigest

+   */

+  public byte[] getReferenceManifestDigest() {

+    return referenceManifestDigest;

+  }

+

+  /**

+   * @param referenceManifestDigest the referenceManifestDigest to set

+   */

+  public void setReferenceManifestDigest(byte[] referenceManifestDigest) {

+    this.referenceManifestDigest = referenceManifestDigest;

+  }

+

+  /**

+   * @return the manifestReferenceDigest

+   */

+  public byte[] getManifestReferenceDigest() {

+    return manifestReferenceDigest;

+  }

+

+  /**

+   * @param manifestReferenceDigest the manifestReferenceDigest to set

+   */

+  public void setManifestReferenceDigest(byte[] manifestReferenceDigest) {

+    this.manifestReferenceDigest = manifestReferenceDigest;

+  }

+  

+}

diff --git a/utils/src/main/java/at/gv/egiz/idlink/ans1/PersonData.java b/utils/src/main/java/at/gv/egiz/idlink/ans1/PersonData.java
new file mode 100644
index 00000000..2a537eb3
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/idlink/ans1/PersonData.java
@@ -0,0 +1,91 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.idlink.ans1;
+
+import iaik.asn1.*;
+
+/**
+ * This class represents the ASN.1 version of the <code>PersonData</code>
+ * of a compressed identity link.
+ * 
+ * <pre>
+PersonData ::= CHOICE { 
+    physcialPerson [0] PhysicalPersonData, 
+    corporateBody [1] CorporateBodyData 
+} </pre>
+ * 
+ * @author mivkovic@egiz.gv.at, mcentner@egiz.gv.at
+ *
+ */
+public class PersonData implements ASN1Type {
+
+  /**
+   * <code>physicalPerson</code>
+   */
+  private PhysicalPersonData physicalPerson; // PhysicalPersonData
+
+  /**
+   * Creates a new <code>PersonData</code> with the given 
+   * <code>physicalPersonData</code>.
+   * 
+   * @param physicalPersonData
+   */
+  public PersonData(PhysicalPersonData physicalPersonData) {
+    physicalPerson = physicalPersonData;
+  }
+
+  /**
+   * Creates a new <code>PersonData</code> from its ASN.1 representation.
+   * 
+   * @param obj
+   * @throws CodingException
+   */
+  public PersonData(ASN1Object obj) throws CodingException {
+    decode(obj);
+  }
+
+  @Override
+  public void decode(ASN1Object obj) throws CodingException {
+    try {
+      physicalPerson = new PhysicalPersonData(obj);
+    } catch (Exception ex) {
+      throw new CodingException(ex.toString());
+    }
+  }
+
+  @Override
+  public ASN1Object toASN1Object() {
+    return physicalPerson.toASN1Object();
+  }
+
+  /**
+   * Returns the DER encoded representation of this <code>PersonData</code>.
+   * 
+   * @return the DER encoded representation of this <code>PersonData</code>
+   */
+  public byte[] getEncoded() {
+    return DerCoder.encode(toASN1Object());
+  }
+
+  /**
+   * @return the physicalPerson
+   */
+  public PhysicalPersonData getPhysicalPerson() {
+    return physicalPerson;
+  }
+  
+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/idlink/ans1/PhysicalPersonData.java b/utils/src/main/java/at/gv/egiz/idlink/ans1/PhysicalPersonData.java
new file mode 100644
index 00000000..a6aea97e
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/idlink/ans1/PhysicalPersonData.java
@@ -0,0 +1,143 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.idlink.ans1;
+
+import iaik.asn1.*;
+
+/**
+ * This class represents the ASN.1 version of the <code>PhysicalPersonData</code>
+ * of an compressed identity link.
+ * 
+ * <pre>PhysicalPersonData ::= SEQUENCE { 
+    baseId UTF8String, 
+    givenName UTF8String, 
+    familyName UTF8String, 
+    dateOfBirth UTF8String
+}</pre>
+ * 
+ * @author mivkovic@egiz.gv.at, mcentner@eigz.gv.at
+ */
+public class PhysicalPersonData implements ASN1Type {
+
+  /**
+   * <code>baseId</code>
+   */
+  private String baseId; // UTF8String
+  
+  /**
+   * <code>givenName</code>
+   */
+  private String givenName; // UTF8String
+  
+  /**
+   * <code>familyName</code>
+   */
+  private String familyName; // UTF8String
+  
+  /**
+   * <code>dataOfBirth</code>
+   */
+  private String dateOfBirth; // UTF8String
+
+  /**
+   * Creates a new <code>PhysicalPersonData</code> with the
+   * given <code>baseId</code>, <code>givenName</code>, <code>familyName</code>
+   * and <code>dataOfBirth</code>.
+   * 
+   * @param baseId
+   * @param givenName
+   * @param familyName
+   * @param dateOfBirth
+   */
+  public PhysicalPersonData(String baseId, String givenName, String familyName, String dateOfBirth) {
+    this.baseId = baseId;
+    this.givenName = givenName;
+    this.familyName = familyName;
+    this.dateOfBirth = dateOfBirth;
+  }
+
+  /**
+   * Creates a new <code>PhysicalPersonData</code> from its ASN.1 representation.
+   * 
+   * @param obj
+   * 
+   * @throws CodingException
+   */
+  public PhysicalPersonData(ASN1Object obj) throws CodingException {
+    decode(obj);
+  }
+
+  @Override
+  public void decode(ASN1Object obj) throws CodingException {
+    try {
+      baseId = (String) ((ASN1Object) obj.getComponentAt(0)).getValue();
+      givenName = (String) ((ASN1Object) obj.getComponentAt(1)).getValue();
+      familyName = (String) ((ASN1Object) obj.getComponentAt(2)).getValue();
+      dateOfBirth = (String) ((ASN1Object) obj.getComponentAt(3)).getValue();
+    } catch (Exception ex) {
+      throw new CodingException(ex.toString());
+    }
+  }
+
+  @Override
+  public ASN1Object toASN1Object() {
+    SEQUENCE ppd = new SEQUENCE();
+    ppd.addComponent(new UTF8String(baseId));
+    ppd.addComponent(new UTF8String(givenName));
+    ppd.addComponent(new UTF8String(familyName));
+    ppd.addComponent(new UTF8String(dateOfBirth));
+    return ppd;
+  }
+
+  /**
+   * Returns the DER encoding of this <code>PhysicalPersonData</code>.
+   * 
+   * @return the DER encoding of this <code>PhysicalPersonData</code>
+   */
+  public byte[] toByteArray() {
+    return DerCoder.encode(toASN1Object());
+  }
+
+  /**
+   * @return the baseId
+   */
+  public String getBaseId() {
+    return baseId;
+  }
+
+  /**
+   * @return the givenName
+   */
+  public String getGivenName() {
+    return givenName;
+  }
+
+  /**
+   * @return the familyName
+   */
+  public String getFamilyName() {
+    return familyName;
+  }
+
+  /**
+   * @return the dateOfBirth
+   */
+  public String getDateOfBirth() {
+    return dateOfBirth;
+  }
+  
+}
\ No newline at end of file
diff --git a/utils/src/main/java/at/gv/egiz/org/apache/tomcat/util/http/AcceptLanguage.java b/utils/src/main/java/at/gv/egiz/org/apache/tomcat/util/http/AcceptLanguage.java
new file mode 100644
index 00000000..231966ac
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/org/apache/tomcat/util/http/AcceptLanguage.java
@@ -0,0 +1,151 @@
+/*
+ *  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 at.gv.egiz.org.apache.tomcat.util.http;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+/**
+ * Util to process the "Accept-Language" header. Used by facade to implement
+ * getLocale() and by StaticInterceptor.
+ *
+ * Not optimized - it's very slow.
+ * 
+ * @author James Duncan Davidson [duncan@eng.sun.com]
+ * @author James Todd [gonzo@eng.sun.com]
+ * @author Jason Hunter [jch@eng.sun.com]
+ * @author Harish Prabandham
+ * @author costin@eng.sun.com
+ */
+public class AcceptLanguage {
+
+    public static Locale getLocale(String acceptLanguage) {
+        if( acceptLanguage == null ) return Locale.getDefault();
+
+        Hashtable<String,Vector<String>> languages =
+            new Hashtable<String,Vector<String>>();
+        Vector<Double> quality = new Vector<Double>();
+        processAcceptLanguage(acceptLanguage, languages, quality);
+
+        if (languages.size() == 0) return Locale.getDefault();
+
+        Vector<Locale> l = new Vector<Locale>();
+        extractLocales( languages,quality, l);
+
+        return (Locale)l.elementAt(0);
+    }
+
+    public static Enumeration getLocales(String acceptLanguage) {
+            // Short circuit with an empty enumeration if null header
+        if (acceptLanguage == null) {
+            Vector<Locale> v = new Vector<Locale>();
+            v.addElement(Locale.getDefault());
+            return v.elements();
+        }
+        
+        Hashtable<String,Vector<String>> languages =
+            new Hashtable<String,Vector<String>>();
+        Vector<Double> quality=new Vector<Double>();
+            processAcceptLanguage(acceptLanguage, languages , quality);
+
+        if (languages.size() == 0) {
+            Vector<Locale> v = new Vector<Locale>();
+            v.addElement(Locale.getDefault());
+            return v.elements();
+        }
+            Vector<Locale> l = new Vector<Locale>();
+            extractLocales( languages, quality , l);
+            return l.elements();
+    }
+
+    private static void processAcceptLanguage( String acceptLanguage,
+            Hashtable<String,Vector<String>> languages, Vector<Double> q)
+    {
+        StringTokenizer languageTokenizer =
+            new StringTokenizer(acceptLanguage, ",");
+
+        while (languageTokenizer.hasMoreTokens()) {
+            String language = languageTokenizer.nextToken().trim();
+            int qValueIndex = language.indexOf(';');
+            int qIndex = language.indexOf('q');
+            int equalIndex = language.indexOf('=');
+            Double qValue = new Double(1);
+
+            if (qValueIndex > -1 &&
+                    qValueIndex < qIndex &&
+                    qIndex < equalIndex) {
+                    String qValueStr = language.substring(qValueIndex + 1);
+                language = language.substring(0, qValueIndex);
+                qValueStr = qValueStr.trim().toLowerCase();
+                qValueIndex = qValueStr.indexOf('=');
+                qValue = new Double(0);
+                if (qValueStr.startsWith("q") &&
+                    qValueIndex > -1) {
+                    qValueStr = qValueStr.substring(qValueIndex + 1);
+                    try {
+                        qValue = new Double(qValueStr.trim());
+                    } catch (NumberFormatException nfe) {
+                    }
+                }
+            }
+
+            // XXX
+            // may need to handle "*" at some point in time
+
+            if (! language.equals("*")) {
+                String key = qValue.toString();
+                Vector<String> v;
+                if (languages.containsKey(key)) {
+                    v = languages.get(key) ;
+                } else {
+                    v= new Vector<String>();
+                    q.addElement(qValue);
+                }
+                v.addElement(language);
+                languages.put(key, v);
+            }
+        }
+    }
+
+    private static void extractLocales(Hashtable languages, Vector q,
+            Vector<Locale> l)
+    {
+        // XXX We will need to order by q value Vector in the Future ?
+        Enumeration e = q.elements();
+        while (e.hasMoreElements()) {
+            Vector v =
+                (Vector)languages.get(((Double)e.nextElement()).toString());
+            Enumeration le = v.elements();
+            while (le.hasMoreElements()) {
+                    String language = (String)le.nextElement();
+                        String country = "";
+                        int countryIndex = language.indexOf("-");
+                if (countryIndex > -1) {
+                    country = language.substring(countryIndex + 1).trim();
+                    language = language.substring(0, countryIndex).trim();
+                }
+                l.addElement(new Locale(language, country));
+            }
+        }
+    }
+
+
+}
diff --git a/utils/src/main/java/at/gv/egiz/slbinding/NamespaceContextCallback.java b/utils/src/main/java/at/gv/egiz/slbinding/NamespaceContextCallback.java
new file mode 100644
index 00000000..08c075ac
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/slbinding/NamespaceContextCallback.java
@@ -0,0 +1,41 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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.
+*/
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package at.gv.egiz.slbinding;
+
+import javax.xml.namespace.NamespaceContext;
+
+/**
+ *
+ * @author clemens
+ */
+public interface NamespaceContextCallback {
+
+    /**
+     * preserves the current namespace context from the XMLEventFilter
+     * @param filter
+     */
+    void preserveNamespaceContext(RedirectEventFilter filter);
+
+    /**
+     * @return the namespace context if preserveNamespaceContext() was called on this object before, null otherwise
+     */
+    NamespaceContext getNamespaceContext();
+}
diff --git a/utils/src/main/java/at/gv/egiz/slbinding/RedirectCallback.java b/utils/src/main/java/at/gv/egiz/slbinding/RedirectCallback.java
new file mode 100644
index 00000000..80fb56dc
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/slbinding/RedirectCallback.java
@@ -0,0 +1,42 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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.
+*/
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package at.gv.egiz.slbinding;
+
+import java.io.ByteArrayOutputStream;
+import javax.xml.stream.XMLStreamException;
+
+/**
+ * 
+ * The beforeUnmarshal(Unmarshaller um, Object parent) methods don't allow to pass the RedirectEventFilter,
+ * so we implement a callback interface common to all generated classes
+ * @author clemens
+ */
+public interface RedirectCallback {
+
+    void enableRedirect(RedirectEventFilter filter) throws XMLStreamException;
+
+    void disableRedirect(RedirectEventFilter filter) throws XMLStreamException;
+
+    /**
+     * @return the redirected stream or null if enableRedirect() was not called before
+     */
+    ByteArrayOutputStream getRedirectedStream();
+}
diff --git a/utils/src/main/java/at/gv/egiz/slbinding/RedirectEventFilter.java b/utils/src/main/java/at/gv/egiz/slbinding/RedirectEventFilter.java
new file mode 100644
index 00000000..d2a7fb30
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/slbinding/RedirectEventFilter.java
@@ -0,0 +1,259 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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.
+*/
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package at.gv.egiz.slbinding;
+
+import java.io.OutputStream;
+import java.util.Set;
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+import javax.xml.stream.EventFilter;
+import javax.xml.stream.XMLEventWriter;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.XMLEvent;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class RedirectEventFilter implements EventFilter {
+
+    public static final String DEFAULT_ENCODING = "UTF-8";
+    private static Log log = LogFactory.getLog(RedirectEventFilter.class);
+    protected XMLEventWriter redirectWriter = null;
+    protected Set<QName> redirectTriggers = null;
+    private int depth = -1;
+    protected NamespaceContext currentNamespaceContext = null;
+
+    /**
+     * Event redirection is disabled, set a redirect stream to enable.
+     */
+    public RedirectEventFilter() {
+        redirectWriter = null;
+    // redirectTriggers = null;
+    }
+
+    /**
+     * 
+     * @param redirectStream
+     *          if null, no events are redirected
+     * @param redirectTriggers
+     *          if null, all events are redirected
+     */
+    public RedirectEventFilter(OutputStream redirectStream, String encoding)
+      throws XMLStreamException { // , List<QName> redirectTriggers
+        if (redirectStream != null) {
+            XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
+            if (encoding == null) {
+                encoding = DEFAULT_ENCODING;
+            }
+            this.redirectWriter = outputFactory.createXMLEventWriter(redirectStream,
+              encoding);
+        }
+    // this.redirectTriggers = redirectTriggers;
+    }
+
+    /**
+     * All startElement events occuring in the redirectTriggers list will trigger
+     * redirection of the entire (sub-)fragment.
+     * 
+     * @param event
+     * @return false if an event is redirected
+     */
+    @Override
+    public boolean accept(XMLEvent event) {
+        int eventType = event.getEventType();
+
+        if (eventType == XMLStreamConstants.START_ELEMENT) {
+            currentNamespaceContext = event.asStartElement().getNamespaceContext();
+        }
+        if (redirectWriter == null) {
+            return true;
+        }
+        if (eventType == XMLStreamConstants.START_ELEMENT) {
+            if (depth >= 0 || triggersRedirect(event.asStartElement().getName())) {
+                depth++;
+            }
+        } else if (eventType == XMLStreamConstants.END_ELEMENT) {
+            if (depth >= 0 && --depth < 0) {
+                // redirect the end element of the trigger, 
+                // but do not redirect the end element of the calling type
+                if (redirectTriggers != null) {
+                    redirectEvent(event);
+                    return false;
+                }
+            }
+        }
+        if (depth >= 0) { //|| (depth == 0 && redirectTriggers == null)) {
+            redirectEvent(event);
+            return false;
+        }
+        return true; // depth < 0;
+
+//    switch (event.getEventType()) {
+//    case XMLStreamConstants.START_ELEMENT:
+//      StartElement startElt = event.asStartElement();
+//      if (depth >= 0 || triggersRedirect(startElt.getName())) {
+//        depth++;
+//      }
+//      // namespace context changes only on start elements
+//      // (first event might not be startElement, but we don't need CDATA's
+//      // namespace context)
+//      currentNamespaceContext = startElt.getNamespaceContext();
+//      break;
+//    case XMLStreamConstants.END_ELEMENT:
+//      // if depth switches from positive to negative, this is the closing tag of
+//      // the trigger (redirect as well!)
+//      if (depth >= 0 && --depth < 0) {
+//        redirectEvent(event);
+//        return false;
+//      }
+//      break;
+//    }
+//    if (depth >= 0) {
+//      redirectEvent(event);
+//      return false;
+//    }
+//    return true; // depth < 0;
+    }
+
+    /**
+     * @param startElt
+     * @return true if the set of triggers contains startElement 
+     * (or no triggers are registered, i.e. everything is redirected)
+     */
+    private boolean triggersRedirect(QName startElement) {
+        if (redirectTriggers != null) {
+            return redirectTriggers.contains(startElement);
+        }
+        return true;
+    }
+
+    private void redirectEvent(XMLEvent event) {
+        try {
+            if (log.isTraceEnabled()) {
+                log.trace("redirecting StAX event " + event);
+            }
+            redirectWriter.add(event);
+        } catch (XMLStreamException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    /**
+     * Enable/disable redirection of <em>all</em> events from now on. 
+     * The redirected events will be UTF-8 encoded and written to the stream.
+     * 
+     * @param redirectstream
+     *          if null, redirection is disabled
+     */
+    public void setRedirectStream(OutputStream redirectStream) throws XMLStreamException {
+        setRedirectStream(redirectStream, DEFAULT_ENCODING, null);
+    }
+
+    /**
+     * Enable/disable redirection of <em>all</em> events from now on. 
+     * 
+     * @param redirectStream if null, redirection is disabled
+     * @param encoding The encoding for the redirect stream
+     * @throws javax.xml.stream.XMLStreamException
+     */
+    public void setRedirectStream(OutputStream redirectStream, String encoding) throws XMLStreamException {
+        setRedirectStream(redirectStream, encoding, null);
+    }
+
+    /**
+     * Enable/disable redirection of all (child) elements contained in redirect triggers.
+     * The redirected events will be UTF-8 encoded and written to the stream.
+     * 
+     * @param redirectstream
+     *          if null, redirection is disabled
+     * @param redirectTriggers elements that trigger the redirection
+     */
+    public void setRedirectStream(OutputStream redirectStream, Set<QName> redirectTriggers) throws XMLStreamException {
+        setRedirectStream(redirectStream, DEFAULT_ENCODING, redirectTriggers);
+    }
+
+    /**
+     * Enable/disable redirection of all (child) elements contained in redirect triggers.
+     * 
+     * @param redirectstream
+     *          if null, redirection is disabled
+     * @param encoding The encoding for the redirect stream
+     * @param redirectTriggers elements that trigger the redirection
+     */
+    public void setRedirectStream(OutputStream redirectStream, String encoding, Set<QName> redirectTriggers) throws XMLStreamException {
+        if (redirectStream != null) {
+            XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
+            if (encoding == null) {
+                encoding = DEFAULT_ENCODING;
+            }
+            redirectWriter = outputFactory.createXMLEventWriter(redirectStream,
+              encoding);
+            if (redirectTriggers == null) {
+                // start redirecting 
+                depth = 0;
+            }
+            this.redirectTriggers = redirectTriggers;
+        } else {
+            redirectWriter = null;
+            this.redirectTriggers = null;
+        }
+    }
+
+    /**
+     * Enable/disable redirection of fragments (defined by elements in
+     * redirectTriggers)
+     * 
+     * @param redirectStream
+     *          if null, redirection is disabled
+     * @param redirectTriggers
+     *          All startElement events occuring in this list will trigger
+     *          redirection of the entire fragment. If null, all events are
+     *          redirected
+     */
+    // public void setRedirectStream(OutputStream redirectStream, List<QName>
+    // redirectTriggers) throws XMLStreamException {
+    // if (redirectStream != null) {
+    // XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
+    // redirectWriter = outputFactory.createXMLEventWriter(redirectStream);
+    // } else {
+    // redirectWriter = null;
+    // }
+    // this.redirectTriggers = (redirectStream == null) ? null : redirectTriggers;
+    // }
+    /**
+     * flushes the internal EventWriter
+     * 
+     * @throws javax.xml.stream.XMLStreamException
+     */
+    public void flushRedirectStream() throws XMLStreamException {
+        redirectWriter.flush();
+    }
+
+    /**
+     * the namespaceContext of the last startelement event read
+     * 
+     * @return
+     */
+    public NamespaceContext getCurrentNamespaceContext() {
+        return currentNamespaceContext;
+    }
+}
diff --git a/utils/src/main/java/at/gv/egiz/slbinding/RedirectUnmarshallerListener.java b/utils/src/main/java/at/gv/egiz/slbinding/RedirectUnmarshallerListener.java
new file mode 100644
index 00000000..08c12146
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/slbinding/RedirectUnmarshallerListener.java
@@ -0,0 +1,68 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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.
+*/
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package at.gv.egiz.slbinding;
+
+import javax.xml.bind.Unmarshaller;
+import javax.xml.stream.XMLStreamException;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Enables event redirection before marshalling a target of type RedirectCallback.
+ * It is up to the target class to implement the redirection (default implementation in RedirectCallback).
+ * Disables event redirection after marshalling (when the closing tag occurs).
+ * @author clemens
+ */
+public class RedirectUnmarshallerListener extends Unmarshaller.Listener {
+
+    private static Log log = LogFactory.getLog(RedirectUnmarshallerListener.class);
+    protected RedirectEventFilter eventFilter;
+
+    public RedirectUnmarshallerListener(RedirectEventFilter eventFilter) {
+        this.eventFilter = eventFilter;
+    }
+
+    @Override
+    public void beforeUnmarshal(Object target, Object parent) {
+        if (target instanceof RedirectCallback) {
+            try {
+                ((RedirectCallback) target).enableRedirect(eventFilter);
+            } catch (XMLStreamException ex) {
+                log.error("failed to enable event redirection for " + target.getClass().getName() + ": " + ex.getMessage(), ex);
+            }
+        }
+        if (target instanceof NamespaceContextCallback) {
+            ((NamespaceContextCallback) target).preserveNamespaceContext(eventFilter);
+        }
+    }
+
+    @Override
+    public void afterUnmarshal(Object target, Object parent) {
+        if (target instanceof RedirectCallback) {
+            try {
+                ((RedirectCallback) target).disableRedirect(eventFilter);
+            } catch (XMLStreamException ex) {
+                log.error("failed to disable event redirection for " + target.getClass().getName() + ": " + ex.getMessage(), ex);
+            }
+        }
+    }
+}
diff --git a/utils/src/main/java/at/gv/egiz/slbinding/impl/SignatureLocationType.java b/utils/src/main/java/at/gv/egiz/slbinding/impl/SignatureLocationType.java
new file mode 100644
index 00000000..494e6972
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/slbinding/impl/SignatureLocationType.java
@@ -0,0 +1,50 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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.
+*/
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package at.gv.egiz.slbinding.impl;
+
+import at.gv.egiz.slbinding.*;
+import javax.xml.bind.annotation.XmlTransient;
+import javax.xml.namespace.NamespaceContext;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ *
+ * @author clemens
+ */
+public class SignatureLocationType extends at.buergerkarte.namespaces.securitylayer._1.SignatureLocationType implements NamespaceContextCallback {
+
+    @XmlTransient
+    private static Log log = LogFactory.getLog(SignatureLocationType.class);
+    @XmlTransient
+    protected NamespaceContext namespaceContext;
+
+    @Override
+    public NamespaceContext getNamespaceContext() {
+        return namespaceContext;
+    }
+
+    @Override
+    public void preserveNamespaceContext(RedirectEventFilter filter) {
+        log.debug("preserving namespace context for SignatureLocationType");
+        namespaceContext = filter.getCurrentNamespaceContext();
+    }
+}
diff --git a/utils/src/main/java/at/gv/egiz/slbinding/impl/TransformsInfoType.java b/utils/src/main/java/at/gv/egiz/slbinding/impl/TransformsInfoType.java
new file mode 100644
index 00000000..b4e988f0
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/slbinding/impl/TransformsInfoType.java
@@ -0,0 +1,70 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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.
+*/
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package at.gv.egiz.slbinding.impl;
+
+import at.gv.egiz.slbinding.*;
+import java.io.ByteArrayOutputStream;
+import java.util.HashSet;
+import java.util.Set;
+import javax.xml.bind.annotation.XmlTransient;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ *
+ * @author clemens
+ */
+public class TransformsInfoType extends at.buergerkarte.namespaces.securitylayer._1.TransformsInfoType implements RedirectCallback {
+
+    @XmlTransient
+    private static Log log = LogFactory.getLog(TransformsInfoType.class);
+    @XmlTransient
+    private static final Set<QName> redirectTriggers = initRedirectTriggers(); 
+    @XmlTransient
+    protected ByteArrayOutputStream redirectOS = null;
+
+    private static Set<QName> initRedirectTriggers() {
+        HashSet<QName> dsigTransforms = new HashSet<QName>();
+        dsigTransforms.add(new QName("http://www.w3.org/2000/09/xmldsig#", "Transforms"));
+        return dsigTransforms;
+    }
+    
+    @Override
+    public void enableRedirect(RedirectEventFilter filter) throws XMLStreamException {
+        log.debug("enabling event redirection for TransformsInfoType");
+        redirectOS = new ByteArrayOutputStream();
+        filter.setRedirectStream(redirectOS, redirectTriggers); 
+    }
+
+    @Override
+    public void disableRedirect(RedirectEventFilter filter) throws XMLStreamException {
+        log.debug("disabling event redirection for TransformsInfoType");
+        filter.flushRedirectStream();
+        filter.setRedirectStream(null);
+    }
+
+    @Override
+    public ByteArrayOutputStream getRedirectedStream() {
+        return redirectOS;
+    }
+}
diff --git a/utils/src/main/java/at/gv/egiz/slbinding/impl/XMLContentType.java b/utils/src/main/java/at/gv/egiz/slbinding/impl/XMLContentType.java
new file mode 100644
index 00000000..c32542aa
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/slbinding/impl/XMLContentType.java
@@ -0,0 +1,60 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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.
+*/
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package at.gv.egiz.slbinding.impl;
+
+import at.gv.egiz.slbinding.RedirectCallback;
+import at.gv.egiz.slbinding.RedirectEventFilter;
+import java.io.ByteArrayOutputStream;
+import javax.xml.bind.annotation.XmlTransient;
+import javax.xml.stream.XMLStreamException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ *
+ * @author clemens
+ */
+public class XMLContentType extends at.buergerkarte.namespaces.securitylayer._1.XMLContentType implements RedirectCallback {
+
+    @XmlTransient
+    private static Log log = LogFactory.getLog(TransformsInfoType.class);
+    @XmlTransient
+    protected ByteArrayOutputStream redirectOS = null;
+
+    @Override
+    public void enableRedirect(RedirectEventFilter filter) throws XMLStreamException {
+        log.debug("enabling event redirection for XMLContentType");
+        redirectOS = new ByteArrayOutputStream();
+        filter.setRedirectStream(redirectOS);
+    }
+
+    @Override
+    public void disableRedirect(RedirectEventFilter filter) throws XMLStreamException {
+        log.debug("disabling event redirection for XMLContentType");
+        filter.flushRedirectStream();
+        filter.setRedirectStream(null);
+    }
+
+    @Override
+    public ByteArrayOutputStream getRedirectedStream() {
+        return redirectOS;
+    }
+}
diff --git a/utils/src/main/java/at/gv/egiz/xades/QualifyingPropertiesException.java b/utils/src/main/java/at/gv/egiz/xades/QualifyingPropertiesException.java
new file mode 100644
index 00000000..e892a13b
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/xades/QualifyingPropertiesException.java
@@ -0,0 +1,40 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.xades;

+

+public class QualifyingPropertiesException extends Exception {

+

+  public QualifyingPropertiesException() {

+    // TODO Auto-generated constructor stub

+  }

+

+  public QualifyingPropertiesException(String message) {

+    super(message);

+    // TODO Auto-generated constructor stub

+  }

+

+  public QualifyingPropertiesException(Throwable cause) {

+    super(cause);

+    // TODO Auto-generated constructor stub

+  }

+

+  public QualifyingPropertiesException(String message, Throwable cause) {

+    super(message, cause);

+    // TODO Auto-generated constructor stub

+  }

+

+}

diff --git a/utils/src/main/java/at/gv/egiz/xades/QualifyingPropertiesFactory.java b/utils/src/main/java/at/gv/egiz/xades/QualifyingPropertiesFactory.java
new file mode 100644
index 00000000..ae159215
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/xades/QualifyingPropertiesFactory.java
@@ -0,0 +1,225 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.xades;

+

+import java.math.BigInteger;

+import java.security.MessageDigest;

+import java.security.NoSuchAlgorithmException;

+import java.security.cert.CertificateEncodingException;

+import java.security.cert.X509Certificate;

+import java.util.Date;

+import java.util.GregorianCalendar;

+import java.util.List;

+import java.util.TimeZone;

+

+import javax.xml.bind.JAXBContext;

+import javax.xml.bind.JAXBElement;

+import javax.xml.bind.JAXBException;

+import javax.xml.bind.Marshaller;

+import javax.xml.bind.PropertyException;

+import javax.xml.crypto.dsig.DigestMethod;

+import javax.xml.datatype.DatatypeConfigurationException;

+import javax.xml.datatype.DatatypeFactory;

+import javax.xml.datatype.XMLGregorianCalendar;

+

+import org.etsi.uri._01903.v1_1.CertIDListType;

+import org.etsi.uri._01903.v1_1.CertIDType;

+import org.etsi.uri._01903.v1_1.DataObjectFormatType;

+import org.etsi.uri._01903.v1_1.DigestAlgAndValueType;

+import org.etsi.uri._01903.v1_1.QualifyingPropertiesType;

+import org.etsi.uri._01903.v1_1.SignaturePolicyIdentifierType;

+import org.etsi.uri._01903.v1_1.SignedDataObjectPropertiesType;

+import org.etsi.uri._01903.v1_1.SignedPropertiesType;

+import org.etsi.uri._01903.v1_1.SignedSignaturePropertiesType;

+import org.w3._2000._09.xmldsig_.DigestMethodType;

+import org.w3._2000._09.xmldsig_.X509IssuerSerialType;

+import org.w3c.dom.Node;

+

+public class QualifyingPropertiesFactory {

+  

+  public static String NS_URI_V1_1_1 = "http://uri.etsi.org/01903/v1.1.1#";

+  

+  public static String SIGNED_PROPERTIES_REFERENCE_TYPE_V1_1_1 = NS_URI_V1_1_1 + "SignedProperties";

+

+  private static QualifyingPropertiesFactory instance;

+  

+  /**

+   * The <code>JAXBContext</code>.

+   */

+  private static JAXBContext jaxbContext;

+  

+  public static synchronized QualifyingPropertiesFactory getInstance() {

+    if (instance == null) {

+      instance = new QualifyingPropertiesFactory();

+    }

+    return instance;

+  }

+

+  private DatatypeFactory datatypeFactory;

+  

+  private org.etsi.uri._01903.v1_1.ObjectFactory qpFactory;

+  

+  private org.w3._2000._09.xmldsig_.ObjectFactory dsFactory;

+

+  public QualifyingPropertiesFactory() {

+    

+    try {

+      datatypeFactory = DatatypeFactory.newInstance();

+    } catch (DatatypeConfigurationException e) {

+      throw new RuntimeException(e);

+    }

+    

+    qpFactory = new org.etsi.uri._01903.v1_1.ObjectFactory();

+    

+    dsFactory = new org.w3._2000._09.xmldsig_.ObjectFactory();

+    

+    StringBuffer packageNames = new StringBuffer();

+    

+    packageNames.append(org.etsi.uri._01903.v1_1.ObjectFactory.class.getPackage().getName());

+    packageNames.append(":");

+    packageNames.append(org.w3._2000._09.xmldsig_.ObjectFactory.class.getPackage().getName());

+

+    try {

+      jaxbContext = JAXBContext.newInstance(packageNames.toString());

+    } catch (JAXBException e) {

+      // we should not get an JAXBException initializing the JAXBContext

+      throw new RuntimeException(e);

+    }

+

+  }

+  

+  public DigestAlgAndValueType createDigestAlgAndValueType(X509Certificate certificate) throws QualifyingPropertiesException {

+    

+    DigestMethodType digestMethodType = dsFactory.createDigestMethodType();

+    digestMethodType.setAlgorithm(DigestMethod.SHA1);

+

+    byte[] digest;

+    try {

+      MessageDigest messageDigest = MessageDigest.getInstance("SHA-1");

+      digest = messageDigest.digest(certificate.getEncoded());

+    } catch (CertificateEncodingException e) {

+      throw new QualifyingPropertiesException(e);

+    } catch (NoSuchAlgorithmException e) {

+      throw new QualifyingPropertiesException(e);

+    }

+

+    DigestAlgAndValueType digestAlgAndValueType = qpFactory.createDigestAlgAndValueType();

+    digestAlgAndValueType.setDigestMethod(digestMethodType);

+    digestAlgAndValueType.setDigestValue(digest);

+

+    return digestAlgAndValueType;

+    

+  }

+  

+  public X509IssuerSerialType createX509IssuerSerialType(X509Certificate certificate) {

+    

+    String name = certificate.getIssuerX500Principal().getName("RFC2253");

+    BigInteger serialNumber = certificate.getSerialNumber();

+    

+    X509IssuerSerialType issuerSerialType = dsFactory.createX509IssuerSerialType();

+    issuerSerialType.setX509IssuerName(name);

+    issuerSerialType.setX509SerialNumber(serialNumber);

+    

+    return issuerSerialType;

+    

+  }

+  

+  public DataObjectFormatType createDataObjectFormatType(String objectReference, String mimeType, String description) {

+    

+    DataObjectFormatType dataObjectFormatType = qpFactory.createDataObjectFormatType();

+    dataObjectFormatType.setObjectReference(objectReference);

+    

+    if (mimeType != null) {

+      dataObjectFormatType.setMimeType(mimeType);

+    }

+    if (description != null) {

+      dataObjectFormatType.setDescription(description);

+    }

+    

+    return dataObjectFormatType;

+  }

+  

+  public JAXBElement<QualifyingPropertiesType> createQualifyingProperties111(Date signingTime, List<X509Certificate> certificates, String idValue, List<DataObjectFormatType> dataObjectFormats) throws QualifyingPropertiesException {

+

+    GregorianCalendar gregorianCalendar = new GregorianCalendar();

+    gregorianCalendar.setTimeZone(TimeZone.getTimeZone("UTC"));

+    gregorianCalendar.setTime(signingTime);

+    

+    SignedSignaturePropertiesType signedSignaturePropertiesType = qpFactory.createSignedSignaturePropertiesType();

+    

+    // SigningTime

+    XMLGregorianCalendar xmlGregorianCalendar = datatypeFactory.newXMLGregorianCalendar(gregorianCalendar);

+    xmlGregorianCalendar.setFractionalSecond(null);

+    signedSignaturePropertiesType.setSigningTime(xmlGregorianCalendar);

+

+    // SigningCertificate

+    CertIDListType certIDListType = qpFactory.createCertIDListType();

+    List<CertIDType> certIDs = certIDListType.getCert();

+

+    for (X509Certificate certificate : certificates) {

+      

+      CertIDType certIDType = qpFactory.createCertIDType();

+      certIDType.setCertDigest(createDigestAlgAndValueType(certificate));

+      certIDType.setIssuerSerial(createX509IssuerSerialType(certificate));

+      

+      certIDs.add(certIDType);

+      

+    }

+    signedSignaturePropertiesType.setSigningCertificate(certIDListType);

+    

+    // SignaturePolicy

+    SignaturePolicyIdentifierType signaturePolicyIdentifierType = qpFactory.createSignaturePolicyIdentifierType();

+    signaturePolicyIdentifierType.setSignaturePolicyImplied(new SignaturePolicyIdentifierType.SignaturePolicyImplied());

+    signedSignaturePropertiesType.setSignaturePolicyIdentifier(signaturePolicyIdentifierType);

+

+    // SignedProperties

+    SignedPropertiesType signedPropertiesType = qpFactory.createSignedPropertiesType();

+    signedPropertiesType.setSignedSignatureProperties(signedSignaturePropertiesType);

+

+    // DataObjectFormat

+    if (dataObjectFormats != null && !dataObjectFormats.isEmpty()) {

+      SignedDataObjectPropertiesType signedDataObjectPropertiesType = qpFactory.createSignedDataObjectPropertiesType();

+      List<DataObjectFormatType> dataObjectFormatTypes = signedDataObjectPropertiesType.getDataObjectFormat();

+      dataObjectFormatTypes.addAll(dataObjectFormats);

+      signedPropertiesType.setSignedDataObjectProperties(signedDataObjectPropertiesType);

+    }

+    

+    signedPropertiesType.setId(idValue);

+    

+    // QualifyingProperties

+    QualifyingPropertiesType qualifyingPropertiesType = qpFactory.createQualifyingPropertiesType();

+    qualifyingPropertiesType.setSignedProperties(signedPropertiesType);

+    

+    return qpFactory.createQualifyingProperties(qualifyingPropertiesType);

+    

+  }

+  

+  public void marshallQualifyingProperties(JAXBElement<QualifyingPropertiesType> qualifyingProperties, Node parent) throws JAXBException {

+    

+    try {

+      Marshaller marshaller = jaxbContext.createMarshaller();

+

+      marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

+

+      marshaller.marshal(qualifyingProperties, parent);

+    } catch (PropertyException e) {

+      throw new RuntimeException(e);

+    } 

+    

+  }

+  

+}

diff --git a/utils/src/main/java/at/gv/egiz/xmldsig/KeyTypeNotSupportedException.java b/utils/src/main/java/at/gv/egiz/xmldsig/KeyTypeNotSupportedException.java
new file mode 100644
index 00000000..3afa6d51
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/xmldsig/KeyTypeNotSupportedException.java
@@ -0,0 +1,65 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.xmldsig;

+

+/**

+ * @author mcentner

+ *

+ */

+public class KeyTypeNotSupportedException extends Exception {

+

+  /**

+   * 

+   */

+  private static final long serialVersionUID = 1L;

+

+  /**

+   * 

+   */

+  public KeyTypeNotSupportedException() {

+    // TODO Auto-generated constructor stub

+  }

+

+  /**

+   * @param message

+   */

+  public KeyTypeNotSupportedException(String message) {

+    super(message);

+    // TODO Auto-generated constructor stub

+  }

+

+  /**

+   * @param cause

+   */

+  public KeyTypeNotSupportedException(Throwable cause) {

+    super(cause);

+    // TODO Auto-generated constructor stub

+  }

+

+  /**

+   * @param message

+   * @param cause

+   */

+  public KeyTypeNotSupportedException(String message, Throwable cause) {

+    super(message, cause);

+    // TODO Auto-generated constructor stub

+  }

+

+}

diff --git a/utils/src/main/java/at/gv/egiz/xmldsig/KeyValueFactory.java b/utils/src/main/java/at/gv/egiz/xmldsig/KeyValueFactory.java
new file mode 100644
index 00000000..c1772312
--- /dev/null
+++ b/utils/src/main/java/at/gv/egiz/xmldsig/KeyValueFactory.java
@@ -0,0 +1,279 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* 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 at.gv.egiz.xmldsig;

+

+import iaik.security.ecc.interfaces.ECDSAParams;

+import iaik.security.ecc.interfaces.ECDSAPublicKey;

+import iaik.security.ecc.math.ecgroup.Coordinate;

+import iaik.security.ecc.math.ecgroup.ECPoint;

+import iaik.security.ecc.math.ecgroup.EllipticCurve;

+import iaik.security.ecc.math.field.BinaryField;

+import iaik.security.ecc.math.field.Field;

+import iaik.security.ecc.math.field.FieldElement;

+import iaik.security.ecc.math.field.PrimeField;

+

+import java.math.BigInteger;

+import java.security.InvalidKeyException;

+import java.security.PublicKey;

+import java.security.interfaces.DSAParams;

+import java.security.interfaces.DSAPublicKey;

+import java.security.interfaces.RSAPublicKey;

+

+import javax.xml.bind.JAXBElement;

+

+import org.w3._2000._09.xmldsig_.DSAKeyValueType;

+import org.w3._2000._09.xmldsig_.RSAKeyValueType;

+import org.w3._2001._04.xmldsig_more_.BasePointParamsType;

+import org.w3._2001._04.xmldsig_more_.CharTwoFieldElemType;

+import org.w3._2001._04.xmldsig_more_.CurveParamsType;

+import org.w3._2001._04.xmldsig_more_.DomainParamsType;

+import org.w3._2001._04.xmldsig_more_.ECDSAKeyValueType;

+import org.w3._2001._04.xmldsig_more_.ECPointType;

+import org.w3._2001._04.xmldsig_more_.ExplicitParamsType;

+import org.w3._2001._04.xmldsig_more_.FieldElemType;

+import org.w3._2001._04.xmldsig_more_.FieldParamsType;

+import org.w3._2001._04.xmldsig_more_.PnBFieldParamsType;

+import org.w3._2001._04.xmldsig_more_.PrimeFieldElemType;

+import org.w3._2001._04.xmldsig_more_.PrimeFieldParamsType;

+import org.w3._2001._04.xmldsig_more_.TnBFieldParamsType;

+import org.w3._2001._04.xmldsig_more_.DomainParamsType.NamedCurve;

+

+public class KeyValueFactory {

+  

+  private static byte[] bigInteger2byteArray(BigInteger bigPositiveInt) {

+    if (bigPositiveInt == null)

+      throw new NullPointerException("Argument 'bigPositiveInt' must not be null");

+    if (bigPositiveInt.signum() != 1)

+      throw new IllegalArgumentException("Argument 'bigPositiveInt' must not be negative");

+

+    byte[] byteRepresentation = bigPositiveInt.toByteArray();

+    if (byteRepresentation[0] == 0) {

+      byte[] oldByteRepresentation = byteRepresentation;

+      byteRepresentation = new byte[oldByteRepresentation.length - 1];

+      System.arraycopy(oldByteRepresentation, 1, byteRepresentation, 0, oldByteRepresentation.length - 1);

+    }

+    return byteRepresentation;

+  }

+  

+  org.w3._2001._04.xmldsig_more_.ObjectFactory ecFactory = new org.w3._2001._04.xmldsig_more_.ObjectFactory();

+

+  org.w3._2000._09.xmldsig_.ObjectFactory dsFactory = new org.w3._2000._09.xmldsig_.ObjectFactory();

+

+  public JAXBElement<?> createKeyValue(PublicKey publicKey) throws KeyTypeNotSupportedException {

+    

+    if (publicKey instanceof RSAPublicKey) {

+      RSAKeyValueType keyValueType = createRSAKeyValueType((RSAPublicKey) publicKey);

+      return dsFactory.createRSAKeyValue(keyValueType);

+    } else if (publicKey instanceof DSAPublicKey) {

+      DSAKeyValueType keyValueType = createKeyValueType((DSAPublicKey) publicKey);

+      return dsFactory.createDSAKeyValue(keyValueType);

+    } else if (publicKey instanceof ECDSAPublicKey) {

+      ECDSAKeyValueType keyValueType = createKeyValueType((ECDSAPublicKey) publicKey);

+      return ecFactory.createECDSAKeyValue(keyValueType);

+    } else if ("EC".equals(publicKey.getAlgorithm())) {

+      byte[] encoded = publicKey.getEncoded();

+      try {

+        iaik.security.ecc.ecdsa.ECPublicKey key = new iaik.security.ecc.ecdsa.ECPublicKey(encoded);

+        ECDSAKeyValueType keyValueType = createKeyValueType(key);

+        return ecFactory.createECDSAKeyValue(keyValueType);

+      } catch (InvalidKeyException e) {

+        throw new KeyTypeNotSupportedException("Public key of type "

+            + publicKey.getAlgorithm() + " (" + publicKey.getClass()

+            + ") not supported.");

+      }

+    } else {

+      throw new KeyTypeNotSupportedException("Public key of type "

+          + publicKey.getAlgorithm() + " (" + publicKey.getClass()

+          + ") not supported.");

+    }

+    

+  }

+  

+  public RSAKeyValueType createRSAKeyValueType(RSAPublicKey publicKey) {

+    

+    RSAKeyValueType keyValueType = dsFactory.createRSAKeyValueType();

+    keyValueType.setExponent(bigInteger2byteArray(publicKey.getPublicExponent()));

+    keyValueType.setModulus(bigInteger2byteArray(publicKey.getModulus()));

+    

+    return keyValueType;

+  }

+  

+  public DSAKeyValueType createKeyValueType(DSAPublicKey publicKey) {

+    

+    DSAKeyValueType keyValueType = dsFactory.createDSAKeyValueType();

+    

+    if (publicKey.getParams() != null) {

+      // P, Q, G

+      DSAParams params = publicKey.getParams();

+      if (params.getP() != null && params.getQ() != null) {

+        keyValueType.setP(bigInteger2byteArray(params.getP()));

+        keyValueType.setQ(bigInteger2byteArray(params.getQ()));

+      }

+      if (params.getG() != null) {

+        keyValueType.setG(bigInteger2byteArray(params.getG()));

+      }

+    }

+    //

+    keyValueType.setY(bigInteger2byteArray(publicKey.getY()));

+    

+    return keyValueType;

+  }

+  

+  public ECDSAKeyValueType createKeyValueType(ECDSAPublicKey publicKey) throws KeyTypeNotSupportedException {

+    

+    ECDSAKeyValueType keyValueType = ecFactory.createECDSAKeyValueType();

+    

+    ECDSAParams params = publicKey.getParameter();

+    if (params != null) {

+      keyValueType.setDomainParameters(createDomainParamsType(params));

+    }

+

+    if (!publicKey.getW().isInfinity()) {

+      keyValueType.setPublicKey(createPointType(publicKey.getW()));

+    }

+    

+    return keyValueType;

+  }

+  

+  public ECPointType createPointType(ECPoint point) throws KeyTypeNotSupportedException {

+    ECPointType pointType = ecFactory.createECPointType();

+    Coordinate affine = point.getCoordinates().toAffine();

+    pointType.setX(createFieldElemType(affine.getX()));

+    pointType.setY(createFieldElemType(affine.getY()));

+    return pointType;

+  }

+  

+  public FieldElemType createFieldElemType(FieldElement fieldElement) throws KeyTypeNotSupportedException {

+    int fieldId = fieldElement.getField().getFieldId();

+    if (fieldId == PrimeField.PRIME_FIELD_ID) {

+      PrimeFieldElemType fieldElemType = ecFactory.createPrimeFieldElemType();

+      fieldElemType.setValue(fieldElement.toBigInt());

+      return fieldElemType;

+    } else if (fieldId == BinaryField.BINARY_FIELD_ID) {

+      CharTwoFieldElemType fieldElemType = ecFactory.createCharTwoFieldElemType();

+      fieldElemType.setValue(fieldElement.toByteArray());

+      return fieldElemType;

+    } else {

+      throw new KeyTypeNotSupportedException("Field element of type " + fieldId + " not supported.");

+    }

+  }

+  

+  public FieldParamsType createFieldParamsType(Field field) throws KeyTypeNotSupportedException {

+    

+    if (field.getFieldId() == PrimeField.PRIME_FIELD_ID) {

+      // PrimeFieldParamsType

+      PrimeFieldParamsType primeFieldParamsType = ecFactory.createPrimeFieldParamsType();

+      primeFieldParamsType.setP(field.getSize());

+      return primeFieldParamsType;

+    } else if (field.getFieldId() == BinaryField.BINARY_FIELD_ID && field instanceof BinaryField) {

+      // CharTwoFieldParamsType

+      

+      BinaryField binaryField = (BinaryField) field;

+      int[] irreduciblePolynomial = binaryField.getIrreduciblePolynomial();

+

+      // The irreducible polynomial as a BinaryFieldValue

+      FieldElement irreducible = binaryField.newElement(irreduciblePolynomial);

+      

+      int order = binaryField.getOrder();

+      int[] coeffPositions = new int[3];

+      

+      // Get coefficients of irreducible polynomial

+      int coeffCount = 2;

+      for (int i = 1; i < order -1; i++) {

+        if (irreducible.testBit(i)) {

+          coeffPositions[coeffCount - 2] = i;

+          coeffCount++;

+          if (coeffCount == 5)

+            break;

+        }

+      }

+      // detect if trinomial or pentanomial base is present...

+      switch (coeffCount) {

+      case 3:

+        // trinomial base

+        TnBFieldParamsType tnBFieldParamsType = ecFactory.createTnBFieldParamsType();

+        tnBFieldParamsType.setM(BigInteger.valueOf(binaryField.getOrder()));

+        tnBFieldParamsType.setK(BigInteger.valueOf(coeffPositions[0]));

+        return tnBFieldParamsType;

+

+      case 5:

+        // pentanomial base

+        PnBFieldParamsType pnBFieldParamsType = ecFactory.createPnBFieldParamsType();

+        pnBFieldParamsType.setM(BigInteger.valueOf(binaryField.getOrder()));

+        pnBFieldParamsType.setK1(BigInteger.valueOf(coeffPositions[0]));

+        pnBFieldParamsType.setK2(BigInteger.valueOf(coeffPositions[1]));

+        pnBFieldParamsType.setK3(BigInteger.valueOf(coeffPositions[2]));

+        return pnBFieldParamsType;

+      

+      default:

+        throw new KeyTypeNotSupportedException("Only trinomial and pentanomial base is supported.");

+      }

+      

+    } else {

+      throw new KeyTypeNotSupportedException("Field element of type " + field.getFieldId() + " not supported.");

+    }

+    

+  }

+  

+  public DomainParamsType createDomainParamsType(ECDSAParams params) throws KeyTypeNotSupportedException {

+    

+    DomainParamsType domainParamsType = ecFactory.createDomainParamsType();

+    EllipticCurve curve = params.getG().getCurve();

+    

+    String oid = params.getOID();

+    if (oid !=  null) {

+      // NamedCurve

+      NamedCurve namedCurve = ecFactory.createDomainParamsTypeNamedCurve();

+      namedCurve.setURN("urn:oid:" + oid);

+      domainParamsType.setNamedCurve(namedCurve);

+    } else {

+      // Explicit parameters

+      ExplicitParamsType explicitParamsType = ecFactory.createExplicitParamsType();

+      explicitParamsType.setFieldParams(createFieldParamsType(curve.getField()));

+      

+      CurveParamsType curveParamsType = ecFactory.createCurveParamsType();

+      

+      // curve coefficients

+      curveParamsType.setA(createFieldElemType(curve.getA()));

+      curveParamsType.setB(createFieldElemType(curve.getB()));

+      

+      // seed

+      if (params.getS() != null) {

+        curveParamsType.setSeed(bigInteger2byteArray(params.getS()));

+      }

+      explicitParamsType.setCurveParams(curveParamsType);

+      

+

+      // BasePoint parameters

+      BasePointParamsType basePointParamsType = ecFactory.createBasePointParamsType();

+      if (!params.getG().isInfinity()) {

+        basePointParamsType.setBasePoint(createPointType(params.getG()));

+      }

+      basePointParamsType.setOrder(params.getR());

+      if(params.getK() != null) {

+        basePointParamsType.setCofactor(params.getK());

+      }

+      explicitParamsType.setBasePointParams(basePointParamsType);

+      

+      domainParamsType.setExplicitParams(explicitParamsType);

+    }

+

+    return domainParamsType;

+    

+  }

+  

+}