1 files changed, 813 insertions, 0 deletions
diff --git a/src/main/java/at/knowcenter/wag/egov/egiz/sig/connectors/BKUConnector.java b/src/main/java/at/knowcenter/wag/egov/egiz/sig/connectors/BKUConnector.java
new file mode 100644
index 0000000..96fa81b
--- /dev/null
+++ b/src/main/java/at/knowcenter/wag/egov/egiz/sig/connectors/BKUConnector.java
@@ -0,0 +1,813 @@
+/*
+ * <copyright> Copyright (c) 2006 by Know-Center, Graz, Austria </copyright>
+ * 
+ * This software is the confidential and proprietary information of Know-Center,
+ * Graz, Austria. You shall not disclose such Confidential Information and shall
+ * use it only in accordance with the terms of the license agreement you entered
+ * into with Know-Center.
+ * 
+ * KNOW-CENTER MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
+ * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
+ * NON-INFRINGEMENT. KNOW-CENTER SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY
+ * LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
+ * DERIVATIVES.
+ * 
+ * $Id: BKUConnector.java,v 1.5 2006/10/31 08:18:41 wprinz Exp $
+ */
+package at.knowcenter.wag.egov.egiz.sig.connectors;
+
+import java.io.UnsupportedEncodingException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+
+import at.knowcenter.wag.egov.egiz.cfg.ConfigLogger;
+import at.knowcenter.wag.egov.egiz.cfg.SettingsReader;
+import at.knowcenter.wag.egov.egiz.exceptions.SettingsException;
+import at.knowcenter.wag.egov.egiz.exceptions.SignatureException;
+import at.knowcenter.wag.egov.egiz.exceptions.SignatureTypesException;
+import at.knowcenter.wag.egov.egiz.sig.ConnectorInformation;
+import at.knowcenter.wag.egov.egiz.sig.LocalConnector;
+import at.knowcenter.wag.egov.egiz.sig.SignatureObject;
+import at.knowcenter.wag.egov.egiz.sig.SignatureResponse;
+import at.knowcenter.wag.egov.egiz.sig.X509Cert;
+import at.knowcenter.wag.egov.egiz.tools.CodingHelper;
+import at.knowcenter.wag.egov.egiz.tools.FileHelper;
+
+/**
+ * Connector for communicating with BKU.
+ * 
+ * @author wlackner
+ * @author wprinz
+ */
+public class BKUConnector implements LocalConnector
+{
+  /**
+   * ConnectorInformation that identifies this Connector to the system.
+   * 
+   * @see at.knowcenter.wag.egov.egiz.sig.ConnectorFactory
+   * @see ConnectorInformation
+   */
+  public static final ConnectorInformation CONNECTOR_INFORMATION = new ConnectorInformation("bku", "BKU");
+
+  /**
+   * The SettingsReader instance
+   */
+  private SettingsReader settings_ = null;
+
+  /**
+   * The logger definition.
+   */
+  private static final Logger logger_ = ConfigLogger.getLogger(BKUConnector.class);
+
+  /**
+   * The empty constructor
+   */
+  public BKUConnector() throws SignatureException
+  {
+    loadSettings();
+  }
+
+  /**
+   * load the inital signature settings
+   * 
+   * @see SettingsReader
+   */
+  private void loadSettings() throws SignatureException
+  {
+    if (settings_ == null)
+    {
+      try
+      {
+        settings_ = SettingsReader.getInstance();
+      }
+      catch (SettingsException e)
+      {
+        String log_message = "Can not load signature settings. Cause:\n" + e.getMessage();
+        logger_.error(log_message);
+        throw new SignatureException(101, log_message, e);
+      }
+    }
+  }
+
+  /**
+   * This method calls the BKU signing a given text. The signaton type is to
+   * used initializing the corresponding SigantureObject. The initialized
+   * SignatureObject is filled out by the parsed BKU-Response. <br>
+   * If an error request is send back from BKU, an error message is generated an
+   * an exception is thrown.
+   * 
+   * @param sigType
+   *          the type of the SignatureObject that should be returned
+   * @param userName
+   *          the name of the user calling this method
+   * @param signText
+   *          the text that shoulf be signed from BKU
+   * @return the complete SingatureObject of the given type filled by values
+   *         from the BKU-Request
+   * @throws SignatureException
+   * @see SignatureObject
+   */
+  public SignatureObject doSign(String sigType, String userName, String signText) throws SignatureException
+  {
+    String request_string = prepareSignRequest(userName, signText, sigType);
+
+    String sign_url = getSignURL(sigType);
+    String response_string = sendRequest(sign_url, request_string);
+
+    return analyzeSignResponse(response_string, sigType);
+  }
+
+  /**
+   * This method generates the BKU verify prozess. It checks if the given
+   * SignatureObject is signed by MOA or BKU. The verify template string is
+   * filled out by the corresponding method.
+   * 
+   * @param normalizedText
+   *          the normalized text to verify
+   * @param sigObject
+   *          the SignatureObject holding the singature values
+   * @return a SignatureResponse object if the verify prozess does not fails
+   * @throws SignatureException
+   * @see SignatureResponse
+   */
+  public SignatureResponse doVerify(String normalizedText,
+      SignatureObject sigObject) throws SignatureException
+  {
+    String request_string = prepareVerifyRequest(normalizedText, sigObject);
+
+    String verify_url = getVerifyURL(sigObject.getSignationType());
+    String response_string = sendRequest(verify_url, request_string);
+
+    return analyzeVerifyResponse(response_string);
+  }
+
+  /**
+   * This method parses the BKU-Response string. It separates the
+   * SignatureValue, X509IssuerName, SigningTime, X509SerialNumber,
+   * X509Certificate, CertDigest, DigestValue and the signation id-s. If the
+   * X509Certificate is extracted it would be stored in the certificates
+   * directory.
+   * 
+   * @param xmlResponse
+   *          the response string from the BKU sign-request
+   * @param sigObj
+   *          the SignatureObject that should be filled
+   * @throws SignatureException
+   *           ErrorCode (303, 304)
+   * @see SignatureObject
+   * @see CodingHelper
+   * @see X509Cert
+   */
+  private void parseCreateXMLResponse(String xmlResponse, SignatureObject sigObj) throws SignatureException
+  {
+    Pattern sig_val_p_s = Pattern.compile("<[\\w]*:?SignatureValue>");
+    Pattern sig_val_p_e = Pattern.compile("</[\\w]*:?SignatureValue>");
+    Pattern iss_nam_p_s = Pattern.compile("<[\\w]*:?X509IssuerName>");
+    Pattern iss_nam_p_e = Pattern.compile("</[\\w]*:?X509IssuerName>");
+    Pattern sig_tim_p_s = Pattern.compile("<[\\w]*:?SigningTime>");
+    Pattern sig_tim_p_e = Pattern.compile("</[\\w]*:?SigningTime>");
+    Pattern ser_num_p_s = Pattern.compile("<[\\w]*:?X509SerialNumber>");
+    Pattern ser_num_p_e = Pattern.compile("</[\\w]*:?X509SerialNumber>");
+    Pattern sig_cer_p_s = Pattern.compile("<[\\w]*:?X509Certificate>");
+    Pattern sig_cer_p_e = Pattern.compile("</[\\w]*:?X509Certificate>");
+
+    Pattern sig_cer_d_p_s = Pattern.compile("<[\\w]*:?CertDigest>");
+    Pattern sig_cer_d_p_e = Pattern.compile("</[\\w]*:?CertDigest>");
+    Pattern dig_val_p_s = Pattern.compile("<[\\w]*:?DigestValue>");
+    Pattern dig_val_p_e = Pattern.compile("</[\\w]*:?DigestValue>");
+
+    Matcher sig_val_m_s = sig_val_p_s.matcher(xmlResponse);
+    Matcher sig_val_m_e = sig_val_p_e.matcher(xmlResponse);
+    Matcher iss_nam_m_s = iss_nam_p_s.matcher(xmlResponse);
+    Matcher iss_nam_m_e = iss_nam_p_e.matcher(xmlResponse);
+    Matcher sig_tim_m_s = sig_tim_p_s.matcher(xmlResponse);
+    Matcher sig_tim_m_e = sig_tim_p_e.matcher(xmlResponse);
+    Matcher ser_num_m_s = ser_num_p_s.matcher(xmlResponse);
+    Matcher ser_num_m_e = ser_num_p_e.matcher(xmlResponse);
+    Matcher sig_cer_m_s = sig_cer_p_s.matcher(xmlResponse);
+    Matcher sig_cer_m_e = sig_cer_p_e.matcher(xmlResponse);
+
+    Matcher sig_cer_d_m_s = sig_cer_d_p_s.matcher(xmlResponse);
+    Matcher sig_cer_d_m_e = sig_cer_d_p_e.matcher(xmlResponse);
+
+    String sig_val = "";
+    String iss_nam = "";
+    String ser_num = "";
+    String sig_tim = "";
+    String sig_cer = "";
+    String sig_dig = "";
+
+    // SignatureValue
+    if (sig_val_m_s.find() && sig_val_m_e.find())
+    {
+      sig_val = xmlResponse.substring(sig_val_m_s.end(), sig_val_m_e.start());
+      sig_val = sig_val.replaceAll("\\s", "");
+      sigObj.setSignationValue(sig_val);
+    }
+    // X509IssuerName
+    if (iss_nam_m_s.find() && iss_nam_m_e.find())
+    {
+      iss_nam = xmlResponse.substring(iss_nam_m_s.end(), iss_nam_m_e.start());
+      sigObj.setSignationIssuer(iss_nam);
+    }
+    // X509SerialNumber
+    if (ser_num_m_s.find() && ser_num_m_e.find())
+    {
+      ser_num = xmlResponse.substring(ser_num_m_s.end(), ser_num_m_e.start());
+      sigObj.setSignationSerialNumber(ser_num);
+    }
+    // SigningTime
+    if (sig_tim_m_s.find() && sig_tim_m_e.find())
+    {
+      sig_tim = xmlResponse.substring(sig_tim_m_s.end(), sig_tim_m_e.start());
+      sigObj.setSignationDate(sig_tim);
+    }
+    // CertDigest
+    if (sig_cer_d_m_s.find() && sig_cer_d_m_e.find())
+    {
+      String cert_digest = xmlResponse.substring(sig_cer_d_m_s.end(), sig_cer_d_m_e.start());
+      Matcher dig_val_m_s = dig_val_p_s.matcher(cert_digest);
+      Matcher dig_val_m_e = dig_val_p_e.matcher(cert_digest);
+      if (dig_val_m_s.find() && dig_val_m_e.find())
+      {
+        sig_dig = cert_digest.substring(dig_val_m_s.end(), dig_val_m_e.start());
+        sigObj.setX509CertificateDigest(sig_dig);
+      }
+    }
+    // extract Subject Name from X509Certificate
+    if (sig_cer_m_s.find() && sig_cer_m_e.find())
+    {
+      sig_cer = xmlResponse.substring(sig_cer_m_s.end(), sig_cer_m_e.start());
+      sig_cer = sig_cer.replaceAll("\\s", "");
+      sigObj.setX509Certificate(sig_cer);
+      X509Cert cert = X509Cert.initByString(sig_cer);
+      if (cert.isX509Cert())
+      {
+        sigObj.setX509Certificate(cert.getCertString());
+        String serial_num = cert.getSerialNumber();
+        String subject_name = cert.getSubjectName();
+        if (!ser_num.equals(serial_num))
+        {
+          SignatureException se = new SignatureException(303, "Serialnumber of certificate and tag X509SerialNumber differs!");
+          throw se;
+        }
+        sigObj.setSignationName(subject_name);
+      }
+    }
+
+    // extract Signature Id's
+    String[] ids = new String[5];
+    ids[0] = extractId(xmlResponse, "signature-");
+    ids[1] = extractId(xmlResponse, "signed-data-reference-");
+    ids[2] = extractId(xmlResponse, "signed-data-object-");
+    ids[3] = extractId(xmlResponse, "etsi-data-reference-");
+    ids[4] = extractId(xmlResponse, "etsi-data-object-");
+    sigObj.setSignationIDs(ids);
+  }
+
+  /**
+   * This emthod extracts id-values from a text. The id is given by the name.
+   * 
+   * @param text
+   *          the id-value that should extract from
+   * @param name
+   *          the id-key
+   * @return the value of the given key in the text
+   */
+  private String extractId(String text, String name)
+  {
+    String id = null;
+    int start_idx = text.indexOf(name) + name.length();
+    int end_idx = text.indexOf("\"", start_idx);
+    id = text.substring(start_idx, end_idx);
+    if (logger_.isDebugEnabled())
+    {
+      logger_.debug("extract id:" + name + id);
+    }
+    return id;
+  }
+
+  /**
+   * This method reads the verify template from the file system and fills out
+   * the template with the SignatureObject values.
+   * 
+   * @param normalizedText
+   *          the normalized text to veryfied
+   * @param sigObject
+   *          the SignatureObject holding the singature values
+   * @return the filled verify template string
+   * @throws SignatureException
+   *           ErrorCode (311, 312, 313)
+   * @see SignatureObject
+   * @see CodingHelper
+   */
+  public String getVerifyTemplate(String normalizedText,
+      SignatureObject sigObject) throws SignatureException
+  {
+    try
+    {
+    if (normalizedText == null || normalizedText.length() == 0)
+    {
+      SignatureException se = new SignatureException(311, "Document can not be verified because normalized text is empty.");
+      throw se;
+    }
+    if (sigObject == null)
+    {
+      SignatureException se = new SignatureException(312, "Document can not be verified because no signature object are set.");
+      throw se;
+    }
+
+    String verify_template = getVerifyTemplateFileName(sigObject.getSignationType());
+    String sig_prop_filename = getSigPropFileName(sigObject.getSignationType());
+
+    String ver_temp_str = FileHelper.readFromFile(SettingsReader.relocateFile(verify_template));
+    String sig_prop_str = FileHelper.readFromFile(SettingsReader.relocateFile(sig_prop_filename));
+    if (logger_.isDebugEnabled())
+    {
+      //logger_.debug(verify_template);
+      logger_.debug(sig_prop_filename);
+    }
+
+    String x509_cert_string = sigObject.getX509CertificateString();
+    if (x509_cert_string == null)
+    {
+      SignatureException se = new SignatureException(313, "Document certificate is not defined.");
+      throw se;
+    }
+    String cert_alg = settings_.getValueFromKey("cert.alg.ecdsa");
+    X509Cert x509_cert = sigObject.getX509Cert();
+    if (x509_cert.isRSA())
+    {
+      cert_alg = settings_.getValueFromKey("cert.alg.rsa");
+    }
+
+    String[] ids = sigObject.getSignationIds();
+    sig_prop_str = sig_prop_str.replaceFirst("SigningTimeReplace", sigObject.getSignationDate());
+    
+    String issuer_name = sigObject.getSignationIssuer();
+    // The issuer is already unicode, so it mustn't be encoded again.
+    //byte[] issuer_name = CodingHelper.encodeUTF8(sigObject.getSignationIssuer());
+    // new String(issuer_name); // this would double encode the String, not to mention the missing encoding
+    sig_prop_str = sig_prop_str.replaceFirst("X509IssuerNameReplace", issuer_name);
+    
+    sig_prop_str = sig_prop_str.replaceFirst("X509SerialNumberReplace", sigObject.getSignationSerialNumber());
+    sig_prop_str = sig_prop_str.replaceFirst("DigestValueX509CertificateReplace", sigObject.getX509CertificateDigest());
+    sig_prop_str = sig_prop_str.replaceFirst("SigIdReplace", ids[0]);
+    sig_prop_str = sig_prop_str.replaceFirst("SigDataRefReplace", ids[1]);
+
+    ver_temp_str = ver_temp_str.replaceFirst("CertAlgReplace", cert_alg);
+    ver_temp_str = ver_temp_str.replaceFirst("TemplateQualifyingPropertiesReplace", sig_prop_str);
+    byte[] sig_prop_code = CodingHelper.buildDigest(sig_prop_str.getBytes("UTF-8"));
+    String sig_prop_hash = CodingHelper.encodeBase64(sig_prop_code);
+    ver_temp_str = ver_temp_str.replaceFirst("DigestValueSignedPropertiesReplace", sig_prop_hash);
+    if (logger_.isDebugEnabled())
+    {
+      logger_.debug("build digest from QualifyingProperties:start");
+      //logger_.debug("DATA  :" + sig_prop_str);
+      logger_.debug("DIGEST:" + sig_prop_hash);
+      logger_.debug("build digest from QualifyingProperties:end");
+    }
+
+    ver_temp_str = ver_temp_str.replaceFirst("SignatureValueReplace", sigObject.getSignationValue());
+    ver_temp_str = ver_temp_str.replaceFirst("X509CertificateReplace", x509_cert_string);
+    byte[] data_value = normalizedText.getBytes("UTF-8");
+    byte[] data_value_hash = CodingHelper.buildDigest(data_value);
+    String object_data_hash = CodingHelper.encodeBase64(data_value_hash);
+    // String object_data = new String(data_value);
+    if (logger_.isDebugEnabled())
+    {
+      logger_.debug("build digest from data object:start");
+      //logger_.debug("DATA  :" + normalizedText);
+      logger_.debug("DIGEST:" + object_data_hash);
+      logger_.debug("build digest from data object:end");
+    }
+
+    //String raw_b64 = CodingHelper.encodeUTF8AsBase64(normalizedText);
+    String raw_b64 = CodingHelper.encodeBase64(data_value);
+    
+    ver_temp_str = ver_temp_str.replaceFirst("Base64ContentReplace", raw_b64);
+    ver_temp_str = ver_temp_str.replaceFirst("DigestValueSignedDataReplace", object_data_hash);
+
+    ver_temp_str = ver_temp_str.replaceAll("SigIdReplace", ids[0]);
+    ver_temp_str = ver_temp_str.replaceAll("SigDataRefReplace", ids[1]);
+    ver_temp_str = ver_temp_str.replaceAll("SigDataObjURIReplace", ids[2]);
+    ver_temp_str = ver_temp_str.replaceAll("EtsiDataRefReplace", ids[3]);
+    ver_temp_str = ver_temp_str.replaceAll("EtsiDataObjURIReplace", ids[4]);
+    if (logger_.isDebugEnabled())
+    {
+      //logger_.debug("VERIFY REQUEST:" + ver_temp_str);
+    }
+
+    return ver_temp_str;
+    }
+    catch (UnsupportedEncodingException e)
+    {
+      throw new SignatureException(310, e);
+    }
+  }
+
+  /**
+   * This method parses the verify response string and return a
+   * SignatureResponse object. The SignatureResponse object is filled out by the
+   * response values from the BKU-response.
+   * 
+   * @param xmlResponse
+   *          the response values from the BKU-verify request
+   * @return SignatureResponse object
+   * @see SignatureResponse
+   */
+  private SignatureResponse parseVerifyXMLResponse(String xmlResponse)
+  {
+    if (logger_.isInfoEnabled())
+    {
+      logger_.info("Try parsing the verify response");
+    }
+
+    Pattern sub_nam_p_s = Pattern.compile("<dsig:X509SubjectName>");
+    Pattern sub_nam_p_e = Pattern.compile("</dsig:X509SubjectName>");
+    Pattern iss_nam_p_s = Pattern.compile("<dsig:X509IssuerName>");
+    Pattern iss_nam_p_e = Pattern.compile("</dsig:X509IssuerName>");
+    Pattern ser_num_p_s = Pattern.compile("<dsig:X509SerialNumber>");
+    Pattern ser_num_p_e = Pattern.compile("</dsig:X509SerialNumber>");
+
+    Pattern sig_chk_p_s = Pattern.compile("<sl:SignatureCheck>");
+    Pattern sig_chk_p_e = Pattern.compile("</sl:SignatureCheck>");
+    Pattern man_chk_p_s = Pattern.compile("<sl:SignatureManifestCheck>");
+    Pattern man_chk_p_e = Pattern.compile("</sl:SignatureManifestCheck>");
+    Pattern cer_chk_p_s = Pattern.compile("<sl:CertificateCheck>");
+    Pattern cer_chk_p_e = Pattern.compile("</sl:CertificateCheck>");
+
+    Pattern code_p_s = Pattern.compile("<sl:Code>");
+    Pattern code_p_e = Pattern.compile("</sl:Code>");
+    Pattern info_p_s = Pattern.compile("<sl:Info>");
+    Pattern info_p_e = Pattern.compile("</sl:Info>");
+
+    Pattern cert_p_s = Pattern.compile("<dsig:X509Certificate>");
+    Pattern cert_p_e = Pattern.compile("</dsig:X509Certificate>");
+
+    Matcher sub_nam_m_s = sub_nam_p_s.matcher(xmlResponse);
+    Matcher sub_nam_m_e = sub_nam_p_e.matcher(xmlResponse);
+    Matcher iss_nam_m_s = iss_nam_p_s.matcher(xmlResponse);
+    Matcher iss_nam_m_e = iss_nam_p_e.matcher(xmlResponse);
+    Matcher ser_num_m_s = ser_num_p_s.matcher(xmlResponse);
+    Matcher ser_num_m_e = ser_num_p_e.matcher(xmlResponse);
+
+    Matcher sig_chk_m_s = sig_chk_p_s.matcher(xmlResponse);
+    Matcher sig_chk_m_e = sig_chk_p_e.matcher(xmlResponse);
+    Matcher man_chk_m_s = man_chk_p_s.matcher(xmlResponse);
+    Matcher man_chk_m_e = man_chk_p_e.matcher(xmlResponse);
+    Matcher cer_chk_m_s = cer_chk_p_s.matcher(xmlResponse);
+    Matcher cer_chk_m_e = cer_chk_p_e.matcher(xmlResponse);
+
+    Matcher cert_m_s = cert_p_s.matcher(xmlResponse);
+    Matcher cert_m_e = cert_p_e.matcher(xmlResponse);
+
+    SignatureResponse sig_res = new SignatureResponse();
+    if (sub_nam_m_s.find() && sub_nam_m_e.find())
+    {
+      String sub_nam = xmlResponse.substring(sub_nam_m_s.end(), sub_nam_m_e.start());
+      sig_res.setX509SubjectName(sub_nam);
+    }
+    if (iss_nam_m_s.find() && iss_nam_m_e.find())
+    {
+      String iss_nam = xmlResponse.substring(iss_nam_m_s.end(), iss_nam_m_e.start());
+      sig_res.setX509IssuerName(iss_nam);
+    }
+    if (ser_num_m_s.find() && ser_num_m_e.find())
+    {
+      String ser_num = xmlResponse.substring(ser_num_m_s.end(), ser_num_m_e.start());
+      sig_res.setX509SerialNumber(ser_num);
+    }
+    if (sig_chk_m_s.find() && sig_chk_m_e.find())
+    {
+      String sig_chk = xmlResponse.substring(sig_chk_m_s.end(), sig_chk_m_e.start());
+      Matcher code_m_s = code_p_s.matcher(sig_chk);
+      Matcher code_m_e = code_p_e.matcher(sig_chk);
+      Matcher info_m_s = info_p_s.matcher(sig_chk);
+      Matcher info_m_e = info_p_e.matcher(sig_chk);
+      if (code_m_s.find() && code_m_e.find())
+      {
+        String code = sig_chk.substring(code_m_s.end(), code_m_e.start());
+        sig_res.setSignatureCheckCode(code);
+      }
+      if (info_m_s.find() && info_m_e.find())
+      {
+        String info = sig_chk.substring(info_m_s.end(), info_m_e.start());
+        sig_res.setSignatureCheckInfo(info);
+      }
+    }
+    if (man_chk_m_s.find() && man_chk_m_e.find())
+    {
+      String man_chk = xmlResponse.substring(man_chk_m_s.end(), man_chk_m_e.start());
+      Matcher code_m_s = code_p_s.matcher(man_chk);
+      Matcher code_m_e = code_p_e.matcher(man_chk);
+      Matcher info_m_s = info_p_s.matcher(man_chk);
+      Matcher info_m_e = info_p_e.matcher(man_chk);
+      if (code_m_s.find() && code_m_e.find())
+      {
+        String code = man_chk.substring(code_m_s.end(), code_m_e.start());
+        sig_res.setSignatureManifestCheckCode(code);
+      }
+      if (info_m_s.find() && info_m_e.find())
+      {
+        String info = man_chk.substring(info_m_s.end(), info_m_e.start());
+        sig_res.setSignatureManifestCheckInfo(info);
+      }
+    }
+    if (cer_chk_m_s.find() && cer_chk_m_e.find())
+    {
+      String cer_chk = xmlResponse.substring(cer_chk_m_s.end(), cer_chk_m_e.start());
+      Matcher code_m_s = code_p_s.matcher(cer_chk);
+      Matcher code_m_e = code_p_e.matcher(cer_chk);
+      Matcher info_m_s = info_p_s.matcher(cer_chk);
+      Matcher info_m_e = info_p_e.matcher(cer_chk);
+      if (code_m_s.find() && code_m_e.find())
+      {
+        String code = cer_chk.substring(code_m_s.end(), code_m_e.start());
+        sig_res.setCertificateCheckCode(code);
+      }
+      if (info_m_s.find() && info_m_e.find())
+      {
+        String info = cer_chk.substring(info_m_s.end(), info_m_e.start());
+        sig_res.setCertificateCheckInfo(info);
+      }
+    }
+    if (cert_m_s.find() && cert_m_e.find())
+    {
+      String cert_string = xmlResponse.substring(cert_m_s.end(), cert_m_e.start());
+
+      X509Cert resp_cert = X509Cert.initByString(cert_string);
+      sig_res.setCertificate(resp_cert);
+    }
+
+    return sig_res;
+  }
+
+  public String prepareSignRequest(String userName, String signText,
+      String signType) throws SignatureException
+  {
+    if (logger_.isInfoEnabled())
+    {
+      logger_.info("Call " + getType() + " connector from user:" + userName);
+    }
+    String keybox_identifier = getSignKeyboxIdentifier(signType);
+    String sign_request_filename = getSignRequestTemplateFileName(signType);
+
+    String sign_req_str = FileHelper.readFromFile(SettingsReader.relocateFile(sign_request_filename));
+    if (logger_.isDebugEnabled())
+    {
+      //logger_.debug(sign_request_filename + "_signText.xml :" + signText);
+    }
+    String raw_b64 = CodingHelper.encodeUTF8AsBase64(signText);
+    if (sign_req_str == null || raw_b64 == null)
+    {
+      throw new SignatureException(300, "Can not read the create xml request template");
+    }
+    sign_req_str = sign_req_str.replaceFirst("KeyboxIdentifierReplace", keybox_identifier);
+    sign_req_str = sign_req_str.replaceFirst("Base64ContentReplace", raw_b64);
+    if (logger_.isDebugEnabled())
+    {
+      //logger_.debug(sign_request_filename + "_request.xml :"+ sign_req_str);
+    }
+
+    return sign_req_str;
+  }
+
+  public String prepareVerifyRequest(String normalizedText,
+      SignatureObject sigObject) throws SignatureException
+  {
+    String verify_request = getVerifyRequestTemplateFileName(sigObject.getSignationType());
+    String verify_req_str = FileHelper.readFromFile(SettingsReader.relocateFile(verify_request));
+
+    if (logger_.isDebugEnabled())
+    {
+      //logger_.debug(verify_request);
+    }
+
+    String verify_template_str = null;
+    if (sigObject.isMOASigned())
+    {
+      MOAConnector moa_conn = new MOAConnector();
+      // get the MOA-template
+      verify_template_str = moa_conn.getVerifyTemplate(normalizedText, sigObject);
+    }
+    else
+    {
+      // get the BKU-template
+      verify_template_str = getVerifyTemplate(normalizedText, sigObject);
+    }
+    verify_req_str = verify_req_str.replaceFirst("XMLContentReplace", verify_template_str);
+    if (logger_.isDebugEnabled())
+    {
+      //logger_.debug(verify_request + "_request.xml : " + verify_req_str);
+    }
+
+    return verify_req_str;
+  }
+
+  /**
+   * Sends the request to the given URL.
+   * 
+   * @param url
+   *          The URL.
+   * @param request_string
+   *          The request string.
+   * @return Returns the response string.
+   * @throws SignatureException
+   *           F.e.
+   */
+  protected String sendRequest(String url, String request_string) throws SignatureException
+  {
+    try
+    {
+      String response_string = BKUPostConnection.doPostRequest(url, request_string);
+      return response_string;
+    }
+    catch (Exception e)
+    {
+      SignatureException se = new SignatureException(320, e);
+      throw se;
+    }
+  }
+
+  public SignatureObject analyzeSignResponse(String response_string,
+      String sigType) throws SignatureException
+  {
+    //String sign_request_filename = getSignRequestTemplateFileName(sigType);
+
+    SignatureObject sig_obj = new SignatureObject();
+    sig_obj.setRawSignatureResponse(response_string);
+    try
+    {
+      sig_obj.setSigType(sigType);
+      sig_obj.initByType();
+    }
+    catch (SignatureTypesException e)
+    {
+      SignatureException se = new SignatureException(300, "Cannot init signature object with type:" + sigType, e);
+      throw se;
+    }
+    if (logger_.isDebugEnabled())
+    {
+      logger_.debug("Signature Type is:" + sig_obj.getSignationType());
+    }
+
+    if (!response_string.equals(""))
+    {
+      Pattern erc_p_s = Pattern.compile("<[\\w]*:?ErrorCode>");
+      Pattern erc_p_e = Pattern.compile("</[\\w]*:?ErrorCode>");
+      Matcher erc_m_s = erc_p_s.matcher(response_string);
+      Matcher erc_m_e = erc_p_e.matcher(response_string);
+      // System.err.println(response_string);
+
+      if (erc_m_s.find() && erc_m_e.find())
+      {
+        if (logger_.isEnabledFor(Level.ERROR))
+        {
+          //logger_.debug(sign_request_filename + "_response.xml : " + response_string);
+          logger_.error("BKU Error response: " + response_string);
+        }
+        Pattern erm_p_s = Pattern.compile("<[\\w]*:?Info>");
+        Pattern erm_p_e = Pattern.compile("</[\\w]*:?Info>");
+        Matcher erm_m_s = erm_p_s.matcher(response_string);
+        Matcher erm_m_e = erm_p_e.matcher(response_string);
+        SignatureException se = new SignatureException(0, "BKUSigExc");
+        String error_code = response_string.substring(erc_m_s.end(), erc_m_e.start());
+        se.setExternalErrorCode(error_code);
+        if (erm_m_s.find() && erm_m_e.find())
+        {
+          String error_mess = response_string.substring(erm_m_s.end(), erm_m_e.start());
+          se.setExternalErrorMessage(error_mess);
+        }
+        throw se;
+      }
+      else
+      {
+        if (logger_.isDebugEnabled())
+        {
+          //logger_.debug(sign_request_filename + "_response.xml : " + response_string);
+        }
+        parseCreateXMLResponse(response_string, sig_obj);
+      }
+    }
+    sig_obj.setSigResponse(response_string);
+    return sig_obj;
+  }
+
+  public SignatureResponse analyzeVerifyResponse(String response_string) throws SignatureException
+  {
+    if (!response_string.equals(""))
+    {
+      Pattern erc_p_s = Pattern.compile("<[\\w]*:?ErrorCode>");
+      Pattern erc_p_e = Pattern.compile("</[\\w]*:?ErrorCode>");
+      Matcher erc_m_s = erc_p_s.matcher(response_string);
+      Matcher erc_m_e = erc_p_e.matcher(response_string);
+
+      if (erc_m_s.find() && erc_m_e.find())
+      {
+        if (logger_.isEnabledFor(Level.ERROR))
+        {
+          //logger_.debug(getType() + "_response.xml : " + response_string);
+          logger_.error(getType() + "_response.xml : " + response_string);
+        }
+        Pattern erm_p_s = Pattern.compile("<[\\w]*:?Info>");
+        Pattern erm_p_e = Pattern.compile("</[\\w]*:?Info>");
+        Matcher erm_m_s = erm_p_s.matcher(response_string);
+        Matcher erm_m_e = erm_p_e.matcher(response_string);
+        SignatureException se = new SignatureException(0, "BKUSigExc");
+        if (erc_m_s.find() && erc_m_e.find())
+        {
+          String error_code = response_string.substring(erc_m_s.end(), erc_m_e.start());
+          se.setExternalErrorCode(error_code);
+        }
+        if (erm_m_s.find() && erm_m_e.find())
+        {
+          String error_mess = response_string.substring(erm_m_s.end(), erm_m_e.start());
+          se.setExternalErrorMessage(error_mess);
+        }
+        throw se;
+      }
+      else
+      {
+        if (logger_.isDebugEnabled())
+        {
+          //logger_.debug(getType() + "_response.xml : " + response_string);
+        }
+        return parseVerifyXMLResponse(response_string);
+      }
+    }
+    return null;
+  }
+
+  protected String getConnectorValueFromProfile(String profile, String key)
+  {
+    String value = settings_.getValueFromKey("sig_obj." + profile + "." + key);
+    if (value == null)
+    {
+      value = settings_.getValueFromKey(key);
+    }
+    return value;
+  }
+
+  public String getSignURL(String profile)
+  {
+    final String key = getType() + "." + ConnectorConfigurationKeys.VALUE_MODE_SIGN + ".url";
+    return getConnectorValueFromProfile(profile, key);
+  }
+
+  protected String getSignRequestTemplateFileName(String profile)
+  {
+    String key = getType() + "." + ConnectorConfigurationKeys.VALUE_MODE_SIGN + ".request";
+    return getConnectorValueFromProfile(profile, key);
+  }
+
+  protected String getSignKeyboxIdentifier(String profile)
+  {
+    String key = getType() + "." + ConnectorConfigurationKeys.VALUE_MODE_SIGN + ".KeyboxIdentifier";
+    return getConnectorValueFromProfile(profile, key);
+  }
+
+  public String getVerifyURL(String profile)
+  {
+    String key = getType() + "." + ConnectorConfigurationKeys.VALUE_MODE_VERIFY + ".url";
+    return getConnectorValueFromProfile(profile, key);
+  }
+
+  protected String getVerifyRequestTemplateFileName(String profile)
+  {
+    String key = getType() + "." + ConnectorConfigurationKeys.VALUE_MODE_VERIFY + ".request";
+    return getConnectorValueFromProfile(profile, key);
+  }
+
+  protected String getVerifyTemplateFileName(String profile)
+  {
+    String key = getType() + "." + ConnectorConfigurationKeys.VALUE_MODE_VERIFY + ".template";
+    return getConnectorValueFromProfile(profile, key);
+  }
+
+  protected String getSigPropFileName(String profile)
+  {
+    String key = getType() + "." + ConnectorConfigurationKeys.VALUE_MODE_VERIFY + ".template.SP";
+    return getConnectorValueFromProfile(profile, key);
+  }
+
+  /**
+   * Returns the type of this BKU-like connector.
+   * 
+   * <p>
+   * All settings keys will be prefixed by this type. So to reuse the BKU
+   * connector, a deriving class has to implement this method specifying an own
+   * type.
+   * </p>
+   * 
+   * @return Returns the type of this BKU-like connector.
+   */
+  protected String getType()
+  {
+    return CONNECTOR_INFORMATION.getIdentifier();
+  }
+}
+\ No newline at end of file