/**
 * <copyright> Copyright 2006 by Know-Center, Graz, Austria </copyright>
 * PDF-AS has been contracted by the E-Government Innovation Center EGIZ, a
 * joint initiative of the Federal Chancellery Austria and Graz University of
 * Technology.
 *
 * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 * http://www.osor.eu/eupl/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 *
 * This product combines work with different licenses. See the "NOTICE" text
 * file for details on the various modules and licenses.
 * The "NOTICE" text file is part of the distribution. Any derivative works
 * that you distribute must include a readable copy of the "NOTICE" text file.
 *
 * $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.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

import at.gv.egiz.pdfas.exceptions.ErrorCode;
import at.gv.egiz.pdfas.exceptions.external.ExternalErrorException;
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;

/**
 * Connector for communicating with BKU.
 * 
 * @deprecated use the new connectors.
 * 
 * @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
   */
  public 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);
    Properties response_properties = sendRequest(sign_url, request_string);

    return analyzeSignResponse(response_properties, 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());
    Properties response_properties = sendRequest(verify_url, request_string);

    return analyzeVerifyResponse(response_properties);
  }

  /**
   * 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(Properties response_properties, SignatureObject sigObj) throws SignatureException
  {
    String xmlResponse = response_properties.getProperty("response_string");
    
    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-");
    
    //TODO hotfix - already deprecated
    String final_ids =SignatureObject.formatSigIds(response_properties, ids);
    //sigObj.setSignationIDs(ids);
    sigObj.setSignationIDs(final_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);
    
    // TODO hotfix! - already deprecated
    final int quot_end_idx = end_idx; 
    final int squot_end_idx = text.indexOf("'", start_idx);
    end_idx = Math.min(quot_end_idx, squot_end_idx);
    // TODO hotfix end! - already deprecated
    
    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 ids_string = sigObject.getSignationIds();
    logger_.debug("ids_string = " + ids_string);
    String[] ids = SignatureObject.parseSigIds(ids_string);

    // TODO hotfix - already deprecated
    final boolean neue_bku = ids[5] != null;
    logger_.debug("ids[5] = " + ids[5]);
    logger_.debug("neue_bku = " + neue_bku);
    if (neue_bku)
    {
      verify_template   = getConnectorValueFromProfile(sigObject.getSignationType(), "bku.verify.template2"); //"./templates/BKUVerifyTemplateB64_neueBKU.xml";
      sig_prop_filename = getConnectorValueFromProfile(sigObject.getSignationType(), "bku.verify.template2.SP"); //"./templates/BKUVerifyTemplateSP_neueBKU.xml";
    }
    

    //String ver_temp_str = FileHelper.readFromFile(SettingsReader.relocateFile(verify_template));
    String ver_temp_str = this.settings_.readInternalResourceAsString(verify_template);
    //String sig_prop_str = FileHelper.readFromFile(SettingsReader.relocateFile(sig_prop_filename));
    String sig_prop_str = this.settings_.readInternalResourceAsString(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(ErrorCode.CERTIFICATE_NOT_FOUND, "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");
    }

     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"), "sha1");
    
    // TODO hotfix - already deprecated
    if (neue_bku)
    {
      final String ETSI_SIGNED_PROPERTIES_START_TAG = "<etsi:SignedProperties"; // xml name spaces follow, so this is not a complete tag...
      final String ETSI_SIGNED_PROPERTIES_END_TAG = "</etsi:SignedProperties>";
      
      final int hash_start = sig_prop_str.indexOf(ETSI_SIGNED_PROPERTIES_START_TAG);
      assert hash_start >= 0;
      final int hash_end = sig_prop_str.indexOf(ETSI_SIGNED_PROPERTIES_END_TAG, hash_start) + ETSI_SIGNED_PROPERTIES_END_TAG.length();
      assert hash_end - ETSI_SIGNED_PROPERTIES_END_TAG.length() >= 0;
      assert hash_end > hash_start;
      
      final String string_to_be_hashed =  sig_prop_str.substring(hash_start, hash_end);
      logger_.debug("etsi:SignedProperties string to be hashed: " + string_to_be_hashed);
      
      logger_.debug("\n--------------------- ETSI properties string to be hashed: start ---------------------");
      logger_.debug(string_to_be_hashed);
      logger_.debug("\n--------------------- ETSI properties string to be hashed: stop  ---------------------");
      
      final byte [] bytes_to_be_hashed = string_to_be_hashed.getBytes("UTF-8");
      sig_prop_code = CodingHelper.buildDigest(bytes_to_be_hashed, "sha1");
    }
    
    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, "sha1");
    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>");

    // [tknall] start qualified certificate
    Pattern cert_qualified_p = Pattern.compile("<sl:QualifiedCertificate/>");
    Matcher cert_qualified_m = cert_qualified_p.matcher(xmlResponse);
    // [tknall] stop qualified certificate

    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();

    // [tknall] start qualified certificate
    sig_res.setQualifiedCertificate(cert_qualified_m.find());
    // [tknall] stop qualified certificate

    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));
    String sign_req_str = this.settings_.readInternalResourceAsString(sign_request_filename);
    //this.verify_request_template = FileHelper.readFromFile(SettingsReader.relocateFile(verify_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));
    String verify_req_str = this.settings_.readInternalResourceAsString(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_req_str.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 Properties sendRequest(String url, String request_string) throws SignatureException
  {
    try
    {
      Properties response_properties = BKUPostConnection.doPostRequest(url, request_string);
      return response_properties;
    }
    catch (Exception e)
    {
      SignatureException se = new SignatureException(320, e);
      throw se;
    }
  }

  public SignatureObject analyzeSignResponse(Properties response_properties,
      String sigType) throws SignatureException
  {
    //String sign_request_filename = getSignRequestTemplateFileName(sigType);

    // TODO hotfix - already deprecated
    String response_string = response_properties.getProperty("response_string");
    
    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);
        String error_code = response_string.substring(erc_m_s.end(), erc_m_e.start());
        String error_mess = null;
        if (erm_m_s.find() && erm_m_e.find())
        {
          error_mess = response_string.substring(erm_m_s.end(), erm_m_e.start());
        }
        throw new SignatureException(new ExternalErrorException(error_code, error_mess));
      }
      else
      {
        if (logger_.isDebugEnabled())
        {
          logger_.debug("signature_response_string: " + response_string);
        }
        parseCreateXMLResponse(response_properties, sig_obj);
      }
    }
    sig_obj.setSigResponse(response_string);
    return sig_obj;
  }

  public SignatureResponse analyzeVerifyResponse(Properties response_properties) throws SignatureException
  {
    String response_string = response_properties.getProperty("response_string");
    
    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);
        String error_code = null;
        if (erc_m_s.find() && erc_m_e.find())
        {
          error_code = response_string.substring(erc_m_s.end(), erc_m_e.start());
        }
        String error_mess = null;
        if (erm_m_s.find() && erm_m_e.find())
        {
          error_mess = response_string.substring(erm_m_s.end(), erm_m_e.start());
        }
        throw new SignatureException(new ExternalErrorException(error_code, error_mess));
      }
      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();
  }
}