initial commit

1 files changed, 656 insertions, 0 deletions

diff --git a/moaSig/moa-sig-lib/src/main/java/at/gv/egovernment/moa/spss/api/impl/SPSSFactoryImpl.java b/moaSig/moa-sig-lib/src/main/java/at/gv/egovernment/moa/spss/api/impl/SPSSFactoryImpl.java
new file mode 100644
index 0000000..ac3d4c9
--- /dev/null
+++ b/moaSig/moa-sig-lib/src/main/java/at/gv/egovernment/moa/spss/api/impl/SPSSFactoryImpl.java
@@ -0,0 +1,656 @@
+/*
+ * Copyright 2003 Federal Chancellery Austria
+ * MOA-SPSS has been developed in a cooperation between BRZ, the Federal
+ * Chancellery Austria - ICT staff unit, 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.
+ */
+
+
+package at.gv.egovernment.moa.spss.api.impl;
+
+import java.io.InputStream;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.security.cert.X509Certificate;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+import at.gv.egovernment.moa.spss.api.SPSSFactory;
+import at.gv.egovernment.moa.spss.api.cmssign.CMSSignatureResponse;
+import at.gv.egovernment.moa.spss.api.cmssign.CreateCMSSignatureRequest;
+import at.gv.egovernment.moa.spss.api.cmssign.CreateCMSSignatureResponse;
+import at.gv.egovernment.moa.spss.api.cmsverify.CMSContent;
+import at.gv.egovernment.moa.spss.api.cmsverify.CMSDataObject;
+import at.gv.egovernment.moa.spss.api.cmsverify.VerifyCMSSignatureRequest;
+import at.gv.egovernment.moa.spss.api.cmsverify.VerifyCMSSignatureResponse;
+import at.gv.egovernment.moa.spss.api.cmsverify.VerifyCMSSignatureResponseElement;
+import at.gv.egovernment.moa.spss.api.common.CheckResult;
+import at.gv.egovernment.moa.spss.api.common.Content;
+import at.gv.egovernment.moa.spss.api.common.MetaInfo;
+import at.gv.egovernment.moa.spss.api.common.SignerInfo;
+import at.gv.egovernment.moa.spss.api.common.Transform;
+import at.gv.egovernment.moa.spss.api.common.X509IssuerSerial;
+import at.gv.egovernment.moa.spss.api.common.XMLDataObjectAssociation;
+import at.gv.egovernment.moa.spss.api.common.XPathFilter;
+import at.gv.egovernment.moa.spss.api.xmlsign.CreateSignatureEnvironmentProfile;
+import at.gv.egovernment.moa.spss.api.xmlsign.CreateSignatureInfo;
+import at.gv.egovernment.moa.spss.api.xmlsign.CreateSignatureLocation;
+import at.gv.egovernment.moa.spss.api.xmlsign.CreateTransformsInfo;
+import at.gv.egovernment.moa.spss.api.xmlsign.CreateTransformsInfoProfile;
+import at.gv.egovernment.moa.spss.api.xmlsign.CreateXMLSignatureRequest;
+import at.gv.egovernment.moa.spss.api.xmlsign.CreateXMLSignatureResponse;
+import at.gv.egovernment.moa.spss.api.xmlsign.DataObjectInfo;
+import at.gv.egovernment.moa.spss.api.xmlsign.ErrorResponse;
+import at.gv.egovernment.moa.spss.api.xmlsign.SignatureEnvironmentResponse;
+import at.gv.egovernment.moa.spss.api.xmlsign.SingleSignatureInfo;
+import at.gv.egovernment.moa.spss.api.xmlverify.ManifestRefsCheckResult;
+import at.gv.egovernment.moa.spss.api.xmlverify.ManifestRefsCheckResultInfo;
+import at.gv.egovernment.moa.spss.api.xmlverify.ReferenceInfo;
+import at.gv.egovernment.moa.spss.api.xmlverify.ReferencesCheckResult;
+import at.gv.egovernment.moa.spss.api.xmlverify.ReferencesCheckResultInfo;
+import at.gv.egovernment.moa.spss.api.xmlverify.SignatureManifestCheckParams;
+import at.gv.egovernment.moa.spss.api.xmlverify.SupplementProfile;
+import at.gv.egovernment.moa.spss.api.xmlverify.TransformParameter;
+import at.gv.egovernment.moa.spss.api.xmlverify.VerifySignatureInfo;
+import at.gv.egovernment.moa.spss.api.xmlverify.VerifySignatureLocation;
+import at.gv.egovernment.moa.spss.api.xmlverify.VerifyTransformsInfoProfile;
+import at.gv.egovernment.moa.spss.api.xmlverify.VerifyXMLSignatureRequest;
+import at.gv.egovernment.moa.spss.api.xmlverify.VerifyXMLSignatureResponse;
+
+/**
+ * Default implementation of <code>SPSSFactory</code>.
+ * 
+ * @author Patrick Peck
+ * @version $Id$
+ */
+public class SPSSFactoryImpl extends SPSSFactory {
+
+  public CreateXMLSignatureRequest createCreateXMLSignatureRequest(
+    String keyIdentifier,
+    List singleSignatureInfos) {
+    CreateXMLSignatureRequestImpl createXMLSignatureRequest =
+      new CreateXMLSignatureRequestImpl();
+    createXMLSignatureRequest.setKeyIdentifier(keyIdentifier);
+    createXMLSignatureRequest.setSingleSignatureInfos(singleSignatureInfos);
+    return createXMLSignatureRequest;
+  }
+  
+  public CreateCMSSignatureRequest createCreateCMSSignatureRequest(
+    String keyIdentifier,
+    List singleSignatureInfos) {
+	  CreateCMSSignatureRequestImpl createCMSSignatureRequest =
+		      new CreateCMSSignatureRequestImpl();
+	  createCMSSignatureRequest.setKeyIdentifier(keyIdentifier);
+	  createCMSSignatureRequest.setSingleSignatureInfos(singleSignatureInfos);
+	  return createCMSSignatureRequest;
+	  
+  }
+  
+  public CreateCMSSignatureResponse createCreateCMSSignatureResponse(List responseElements) {
+	  CreateCMSSignatureResponseImpl createCMSSignatureResponse = new CreateCMSSignatureResponseImpl();
+	  createCMSSignatureResponse.setResponseElements(responseElements);
+	  return createCMSSignatureResponse;
+  }
+  
+  
+  public CMSSignatureResponse createCMSSignatureResponse(String base64value) {
+	  CMSSignatureResponseImpl cmsSignatureResponse = new CMSSignatureResponseImpl();
+	  cmsSignatureResponse.setCMSSignature(base64value);
+	  
+	  return cmsSignatureResponse;
+  }
+  
+
+  public SingleSignatureInfo createSingleSignatureInfo(
+    List dataObjectInfos,
+    CreateSignatureInfo createSignatureInfo,
+    boolean securityLayerConform) {
+    SingleSignatureInfoImpl singleSignatureInfo = new SingleSignatureInfoImpl();
+    singleSignatureInfo.setDataObjectInfos(dataObjectInfos);
+    singleSignatureInfo.setCreateSignatureInfo(createSignatureInfo);
+    singleSignatureInfo.setSecurityLayerConform(securityLayerConform);
+    return singleSignatureInfo;
+  }
+  
+  public at.gv.egovernment.moa.spss.api.cmssign.SingleSignatureInfo createSingleSignatureInfoCMS(
+		  at.gv.egovernment.moa.spss.api.cmssign.DataObjectInfo dataObjectInfo,		    
+		    boolean securityLayerConform) {
+		    SingleSignatureInfoCMSImpl singleSignatureInfo = new SingleSignatureInfoCMSImpl();
+		    singleSignatureInfo.setDataObjectInfo(dataObjectInfo);
+		    singleSignatureInfo.setSecurityLayerConform(securityLayerConform);
+		    return singleSignatureInfo;
+		  }
+  
+  public DataObjectInfo createDataObjectInfo(
+    String structure,
+    boolean childOfManifest,
+    Content dataObject,
+    CreateTransformsInfoProfile createTransformsInfoProfile) {
+    DataObjectInfoImpl dataObjectInfo = new DataObjectInfoImpl();
+    dataObjectInfo.setStructure(structure);
+    dataObjectInfo.setChildOfManifest(childOfManifest);
+    dataObjectInfo.setDataObject(dataObject);
+    dataObjectInfo.setCreateTransformsInfoProfile(createTransformsInfoProfile);
+    return dataObjectInfo;
+  }
+  
+  public at.gv.egovernment.moa.spss.api.cmssign.DataObjectInfo createDataObjectInfo(
+		    String structure,
+		    CMSDataObject dataObject) {
+		    DataObjectInfoCMSImpl dataObjectInfo = new DataObjectInfoCMSImpl();
+		    dataObjectInfo.setStructure(structure);
+		    dataObjectInfo.setDataObject(dataObject);
+		    return dataObjectInfo;
+		  }
+
+  public CreateTransformsInfoProfile createCreateTransformsInfoProfile(String profileID) {
+
+    CreateTransformsInfoProfileIDImpl createTransformsInfoProfile =
+      new CreateTransformsInfoProfileIDImpl();
+    createTransformsInfoProfile.setCreateTransformsInfoProfileID(profileID);
+    return createTransformsInfoProfile;
+  }
+
+  public CreateTransformsInfoProfile createCreateTransformsInfoProfile(
+    CreateTransformsInfo transformsInfo,
+    List supplements) {
+    CreateTransformsInfoProfileExplicitImpl createTransformsInfoProfile =
+      new CreateTransformsInfoProfileExplicitImpl();
+    createTransformsInfoProfile.setCreateTransformsInfo(transformsInfo);
+    createTransformsInfoProfile.setSupplements(supplements);
+    return createTransformsInfoProfile;
+  }
+
+  public CreateTransformsInfo createCreateTransformsInfo(
+    List transforms,
+    MetaInfo finalDataMetaInfo) {
+    CreateTransformsInfoImpl createTransformsInfo =
+      new CreateTransformsInfoImpl();
+      
+    createTransformsInfo.setTransforms(transforms);
+    createTransformsInfo.setFinalDataMetaInfo(finalDataMetaInfo);
+    return createTransformsInfo;
+  }
+
+  public CreateSignatureInfo createCreateSignatureInfo(
+    Content createSignatureEnvironment,
+    CreateSignatureEnvironmentProfile createSignatureEnvironmentProfile) {
+    CreateSignatureInfoImpl createSignatureInfo = new CreateSignatureInfoImpl();
+    createSignatureInfo.setCreateSignatureEnvironment(
+      createSignatureEnvironment);
+    createSignatureInfo.setCreateSignatureEnvironmentProfile(
+      createSignatureEnvironmentProfile);
+    return createSignatureInfo;
+  }
+
+  public CreateSignatureEnvironmentProfile createCreateSignatureEnvironmentProfile(
+    CreateSignatureLocation createSignatureLocation,
+    List supplements) {
+    CreateSignatureEnvironmentProfileExplicitImpl createSignatureEnvironmentProfile =
+      new CreateSignatureEnvironmentProfileExplicitImpl();
+    createSignatureEnvironmentProfile.setCreateSignatureLocation(
+      createSignatureLocation);
+    createSignatureEnvironmentProfile.setSupplements(supplements);
+    return createSignatureEnvironmentProfile;
+  }
+
+  public CreateSignatureLocation createCreateSignatureLocation(
+    String signatureLocationXPath,
+    int signatureLocationIndex,
+    Map namespaceDeclarations) {
+    CreateSignatureLocationImpl createSignatureLocation =
+      new CreateSignatureLocationImpl();
+    createSignatureLocation.setIndex(signatureLocationIndex);
+    createSignatureLocation.setNamespaceDeclarations(namespaceDeclarations);
+    createSignatureLocation.setXPathExpression(signatureLocationXPath);
+    return createSignatureLocation;
+  }
+
+  public CreateSignatureEnvironmentProfile createCreateSignatureEnvironmentProfile(String profileID) {
+    CreateSignatureEnvironmentProfileIDImpl createSignatureEnvironmentProfile =
+      new CreateSignatureEnvironmentProfileIDImpl();
+    createSignatureEnvironmentProfile.setCreateSignatureEnvironmentProfileID(
+      profileID);
+    return createSignatureEnvironmentProfile;
+  }
+
+  public CreateXMLSignatureResponse createCreateXMLSignatureResponse(List responseElements) {
+    CreateXMLSignatureResponseImpl createXMLSignatureResponse =
+      new CreateXMLSignatureResponseImpl();
+    createXMLSignatureResponse.setResponseElements(responseElements);
+    return createXMLSignatureResponse;
+  }
+
+  public SignatureEnvironmentResponse createSignatureEnvironmentResponse(Element signatureEnvironment) {
+    SignatureEnvironmentResponseImpl signatureEnvironmentResponse =
+      new SignatureEnvironmentResponseImpl();
+    signatureEnvironmentResponse.setSignatureEnvironment(signatureEnvironment);
+    return signatureEnvironmentResponse;
+  }
+
+  public ErrorResponse createErrorResponse(int code, String info) {
+    ErrorResponseImpl errorResponse = new ErrorResponseImpl();
+    errorResponse.setErrorCode(code);
+    errorResponse.setInfo(info);
+    return errorResponse;
+  }
+
+  public VerifyCMSSignatureRequest createVerifyCMSSignatureRequest(
+    int[] signatories,
+    Date dateTime,
+    InputStream cmsSignature,
+    CMSDataObject dataObject,
+    String trustProfileID) {
+    VerifyCMSSignatureRequestImpl verifyCMSSignatureRequest =
+      new VerifyCMSSignatureRequestImpl();
+    verifyCMSSignatureRequest.setDateTime(dateTime);
+    verifyCMSSignatureRequest.setCMSSignature(cmsSignature);
+    verifyCMSSignatureRequest.setDataObject(dataObject);
+    verifyCMSSignatureRequest.setTrustProfileId(trustProfileID);
+    verifyCMSSignatureRequest.setSignatories(signatories);
+    return verifyCMSSignatureRequest;
+  }
+
+  public CMSDataObject createCMSDataObject(
+    MetaInfo metaInfo,
+    CMSContent content,
+    BigDecimal excludeByteRangeFrom,
+    BigDecimal excludeByteRangeTo) {
+      
+    CMSDataObjectImpl cmsDataObject = new CMSDataObjectImpl();
+    cmsDataObject.setMetaInfo(metaInfo);
+    cmsDataObject.setContent(content);
+    cmsDataObject.setExcludeByteRangeFrom(excludeByteRangeFrom);
+    cmsDataObject.setExcludeByteRangeTo(excludeByteRangeTo);
+    
+    return cmsDataObject;
+  }
+  
+  public CMSContent createCMSContent(InputStream binaryContent) {
+    CMSContentExplicitImpl cmsContent = new CMSContentExplicitImpl();
+    
+    cmsContent.setBinaryContent(binaryContent);
+    return cmsContent;
+  }
+
+  public CMSContent createCMSContent(String referenceURI) {
+    CMSContentReferenceImpl cmsContent = new CMSContentReferenceImpl();
+    
+    cmsContent.setReference(referenceURI);
+    return cmsContent;
+  }  
+  
+
+  public CMSDataObject createCMSDataObject(
+    MetaInfo metaInfo,
+    String referenceURI) {
+    CMSDataObjectImpl cmsDataObject = new CMSDataObjectImpl();
+    CMSContentReferenceImpl cmsContent = new CMSContentReferenceImpl();
+    cmsDataObject.setMetaInfo(metaInfo);
+    cmsContent.setReference(referenceURI);
+    return cmsDataObject;
+  }
+
+  public VerifyCMSSignatureResponse createVerifyCMSSignatureResponse(List responseElements) {
+    VerifyCMSSinatureResponseImpl verifyCMSSignatureResponse =
+      new VerifyCMSSinatureResponseImpl();
+    verifyCMSSignatureResponse.setResponseElements(responseElements);
+    return verifyCMSSignatureResponse;
+  }
+
+  public VerifyCMSSignatureResponseElement createVerifyCMSSignatureResponseElement(
+    SignerInfo signerInfo,
+    CheckResult signatureCheck,
+    CheckResult certificateCheck) {
+    VerifyCMSSignatureResponseElementImpl verifyCMSSignatureResponseElement =
+      new VerifyCMSSignatureResponseElementImpl();
+    verifyCMSSignatureResponseElement.setSignerInfo(signerInfo);
+    verifyCMSSignatureResponseElement.setSignatureCheck(signatureCheck);
+    verifyCMSSignatureResponseElement.setCertificateCheck(certificateCheck);
+    
+    return verifyCMSSignatureResponseElement;
+  }
+
+  public VerifyXMLSignatureRequest createVerifyXMLSignatureRequest(
+    Date dateTime,
+    VerifySignatureInfo verifySignatureInfo,
+    List supplementProfiles,
+    SignatureManifestCheckParams signatureManifestParams,
+    boolean returnHashInputData,
+    String trustProfileID) {
+    VerifyXMLSignatureRequestImpl verifyXMLSignatureRequest =
+      new VerifyXMLSignatureRequestImpl();
+    verifyXMLSignatureRequest.setDateTime(dateTime);
+    verifyXMLSignatureRequest.setSignatureInfo(verifySignatureInfo);
+    verifyXMLSignatureRequest.setSupplementProfiles(supplementProfiles);
+    verifyXMLSignatureRequest.setSignatureManifestCheckParams(
+      signatureManifestParams);
+    verifyXMLSignatureRequest.setReturnHashInputData(returnHashInputData);
+    verifyXMLSignatureRequest.setTrustProfileId(trustProfileID);
+    return verifyXMLSignatureRequest;
+  }
+
+  public VerifySignatureInfo createVerifySignatureInfo(
+    Content verifySignatureEnvironment,
+    VerifySignatureLocation verifySignatureLocation) {
+    VerifySignatureInfoImpl verifySignatureInfo = new VerifySignatureInfoImpl();
+    verifySignatureInfo.setVerifySignatureEnvironment(
+      verifySignatureEnvironment);
+    verifySignatureInfo.setVerifySignatureLocation(verifySignatureLocation);
+    return verifySignatureInfo;
+  }
+
+  public VerifySignatureLocation createVerifySignatureLocation(
+    String xPathExpression,
+    Map namespaceDeclarations) {
+    VerifySignatureLocationImpl verifySignatureLocation =
+      new VerifySignatureLocationImpl();
+    verifySignatureLocation.setXPathExpression(xPathExpression);
+    verifySignatureLocation.setNamespaceDeclarations(namespaceDeclarations);
+    return verifySignatureLocation;
+  }
+
+  public SupplementProfile createSupplementProfile(String profileID) {
+    SupplementProfileIDImpl supplementProfileID = new SupplementProfileIDImpl();
+    supplementProfileID.setSupplementProfileID(profileID);
+    return supplementProfileID;
+  }
+
+  public SupplementProfile createSupplementProfile(XMLDataObjectAssociation supplementProfile) {
+    SupplementProfileExplicitImpl supplementProfileExplicit =
+      new SupplementProfileExplicitImpl();
+    supplementProfileExplicit.setSupplementProfile(supplementProfile);
+    return supplementProfileExplicit;
+  }
+
+  public SignatureManifestCheckParams createSignatureManifestCheckParams(
+    List referenceInfos,
+    boolean returnReferenceInputData) {
+    SignatureManifestCheckParamsImpl signatureManifestCheckParams =
+      new SignatureManifestCheckParamsImpl();
+    signatureManifestCheckParams.setReferenceInfos(referenceInfos);
+    signatureManifestCheckParams.setReturnReferenceInputData(
+      returnReferenceInputData);
+    return signatureManifestCheckParams;
+  }
+
+  public ReferenceInfo createReferenceInfo(List verifyTransformsInfoProfiles) {
+    ReferenceInfoImpl referenceInfo = new ReferenceInfoImpl();
+    referenceInfo.setVerifyTransformsInfoProfiles(verifyTransformsInfoProfiles);
+    return referenceInfo;
+  }
+
+  public VerifyTransformsInfoProfile createVerifyTransformsInfoProfile(
+    List transforms,
+    List transformParameters) {
+    VerifyTransformsInfoProfileExplicitImpl verifyTransformsInfoProfile =
+      new VerifyTransformsInfoProfileExplicitImpl();
+    
+    verifyTransformsInfoProfile.setTransforms(transforms);
+    verifyTransformsInfoProfile.setTransformParameters(transformParameters);
+    
+    return verifyTransformsInfoProfile;
+  }
+
+  public VerifyTransformsInfoProfile createVerifyTransformsInfoProfile(String profileID) {
+    VerifyTransformsInfoProfileIDImpl verifyTransformsInfoProfile =
+      new VerifyTransformsInfoProfileIDImpl();
+    verifyTransformsInfoProfile.setVerifyTransformsInfoProfileID(profileID);
+    return verifyTransformsInfoProfile;
+  }
+
+
+  public TransformParameter createTransformParameter(String URI, String digestMethod, byte[] digestValue) {
+    TransformPatameterHashImpl transformParameter =
+      new TransformPatameterHashImpl();
+    transformParameter.setURI(URI);
+    transformParameter.setDigestMethod(digestMethod);
+    transformParameter.setDigestValue(digestValue);
+    return transformParameter;
+  }
+
+  public TransformParameter createTransformParameter(
+    String URI,
+    InputStream binaryData) {
+    TransformParameterBinaryImpl transformParameter =
+      new TransformParameterBinaryImpl();
+    transformParameter.setURI(URI);
+    transformParameter.setBinaryContent(binaryData);
+    return transformParameter;
+  }
+
+  public TransformParameter createTransformParameter(String URI) {
+    TransformParameterURIImpl transformParameter =
+      new TransformParameterURIImpl();
+    transformParameter.setURI(URI);
+    return transformParameter;
+  }
+
+  public VerifyXMLSignatureResponse createVerifyXMLSignatureResponse(
+    SignerInfo signerInfo,
+    List hashInputDatas,
+    List referenceInputDatas,
+    ReferencesCheckResult signatureCheck,
+    ReferencesCheckResult signatureManifestCheck,
+    List xmlDsigManifestChecks,
+    CheckResult certificateCheck) {
+    VerifyXMLSignatureResponseImpl verifyXMLSignatureResponse =
+      new VerifyXMLSignatureResponseImpl();
+    verifyXMLSignatureResponse.setSignerInfo(signerInfo);
+    verifyXMLSignatureResponse.setHashInputDatas(hashInputDatas);
+    verifyXMLSignatureResponse.setReferenceInputDatas(referenceInputDatas);
+    verifyXMLSignatureResponse.setSignatureCheck(signatureCheck);
+    verifyXMLSignatureResponse.setSignatureManifestCheck(
+      signatureManifestCheck);
+    verifyXMLSignatureResponse.setXMLDsigManifestChecks(xmlDsigManifestChecks);
+    verifyXMLSignatureResponse.setCertificateCheck(certificateCheck);
+    
+    return verifyXMLSignatureResponse;
+  }
+
+  public ReferencesCheckResult createReferencesCheckResult(
+    int code,
+    ReferencesCheckResultInfo info) {
+    ReferencesCheckResultImpl referencesCheckResult =
+      new ReferencesCheckResultImpl();
+    referencesCheckResult.setCode(code);
+    referencesCheckResult.setInfo(info);
+    return referencesCheckResult;
+  }
+
+  public ReferencesCheckResultInfo createReferencesCheckResultInfo(
+    NodeList anyOtherInfo,
+    int[] failedReferences) {
+    ReferencesCheckResultInfoImpl referencesCheckResultInfo =
+      new ReferencesCheckResultInfoImpl();
+    referencesCheckResultInfo.setAnyOtherInfo(anyOtherInfo);
+    referencesCheckResultInfo.setFailedReferences(failedReferences);
+    return referencesCheckResultInfo;
+  }
+
+  public ManifestRefsCheckResult createManifestRefsCheckResult(
+    int code,
+    ManifestRefsCheckResultInfo info) {
+    ManifestRefsCheckResultImpl manifestRefsCheckResult =
+      new ManifestRefsCheckResultImpl();
+    manifestRefsCheckResult.setCode(code);
+    manifestRefsCheckResult.setInfo(info);
+    return manifestRefsCheckResult;
+  }
+  
+  public ManifestRefsCheckResultInfo createManifestRefsCheckResultInfo(
+    NodeList anyOtherInfo,
+    int[] failedReferences,
+    int referringSigReference) {
+    ManifestRefsCheckResultInfoImpl manifestRefsCheckResultInfo =
+      new ManifestRefsCheckResultInfoImpl();
+    manifestRefsCheckResultInfo.setAnyOtherInfo(anyOtherInfo);
+    manifestRefsCheckResultInfo.setReferringSignatureReference(
+      referringSigReference);
+    manifestRefsCheckResultInfo.setFailedReferences(failedReferences);
+    return manifestRefsCheckResultInfo;
+  }
+
+  public Content createContent(InputStream binaryData, String referenceURI) {
+    ContentBinaryImpl content = new ContentBinaryImpl();
+    content.setBinaryContent(binaryData);
+    content.setReference(referenceURI);
+    return content;
+  }
+
+  public Content createContent(String locationReferenceURI, String referenceURI) {
+    ContentLocRefImpl content = new ContentLocRefImpl();
+    content.setLocationReferenceURI(locationReferenceURI);
+    content.setReference(referenceURI);
+    return content;
+  }
+
+  public Content createContent(String referenceURI) {
+    ContentReferenceImpl content = new ContentReferenceImpl();
+    content.setReference(referenceURI);
+    return content;
+  }
+
+  public Content createContent(NodeList xmlData, String referenceURI) {
+    ContentXMLImpl content = new ContentXMLImpl();
+    content.setXMLContent(xmlData);
+    content.setReference(referenceURI);
+    return content;
+  }
+  
+  public XMLDataObjectAssociation createXMLDataObjectAssociation(
+    MetaInfo metaInfo,
+    Content xmlContent) {
+    XMLDataObjectAssociationImpl xmlDataObjectAssociation =
+      new XMLDataObjectAssociationImpl();
+    xmlDataObjectAssociation.setMetaInfo(metaInfo);
+    xmlDataObjectAssociation.setContent(xmlContent);
+    return xmlDataObjectAssociation;
+  }
+
+  public MetaInfo createMetaInfo(
+    String mimeType,
+    String description,
+    NodeList otherInfo,
+    String type) {
+    MetaInfoImpl metaInfo = new MetaInfoImpl();
+    metaInfo.setMimeType(mimeType);
+    metaInfo.setDescription(description);
+    metaInfo.setAnyElements(otherInfo);
+    metaInfo.setType(type);
+    return metaInfo;
+  }
+
+  public Transform createCanonicalizationTransform(String algorithmURI) {
+    CanonicalizationTransformImpl transform = new CanonicalizationTransformImpl(algorithmURI);
+    return transform;
+  }
+  
+  public Transform createExclusiveCanonicalizationTransform(String algorithmURI, List inclusiveNamespacePrefixes) {
+    ExclusiveCanonicalizationTransformImpl transform = new ExclusiveCanonicalizationTransformImpl(algorithmURI);
+    transform.setInclusiveNamespacePrefixes(inclusiveNamespacePrefixes);
+    return transform;
+  }
+  
+  public Transform createBase64Transform() {
+    Base64TransformImpl transform = new Base64TransformImpl();
+    return transform;
+  }
+
+  public Transform createEnvelopedSignatureTransform() {
+    EnvelopedSignatureTransformImpl transform =
+      new EnvelopedSignatureTransformImpl();
+    return transform;
+  }
+
+  public Transform createXSLTTransform(Element styleSheet) {
+    XSLTransformImpl transform = new XSLTransformImpl();
+    transform.setStylesheet(styleSheet);
+    return transform;
+  }
+
+  public Transform createXPathTransform(
+    String xPathExpression,
+    Map namespaceDeclarations) {
+    XPathTransformImpl transform = new XPathTransformImpl();
+    transform.setXPathExpression(xPathExpression);
+    transform.setNamespaceDelcarations(namespaceDeclarations);
+    return transform;
+  }
+
+  public Transform createXPathFilter2Transform(List xPathFilters) {
+    XPathFilter2TransformImpl transform = new XPathFilter2TransformImpl();
+    transform.setFilters(xPathFilters);
+    return transform;
+  }
+
+  public XPathFilter createXPathFilter(
+    String filterType,
+    String xPathExpression,
+    Map namespaceDeclarations) {
+    XPathFilterImpl xPathFilter = new XPathFilterImpl();
+    xPathFilter.setFilterType(filterType);
+    xPathFilter.setXPathExpression(xPathExpression);
+    xPathFilter.setNamespaceDelcarations(namespaceDeclarations);
+    return xPathFilter;
+  }
+
+  public CheckResult createCheckResult(int code, NodeList info) {
+    CheckResultImpl checkResult = new CheckResultImpl();
+    checkResult.setCode(code);
+    checkResult.setInfo(info);
+    return checkResult;
+  }
+  
+
+  public SignerInfo createSignerInfo(
+    X509Certificate signerCertificate,
+    boolean qualifiedCertificate,
+    boolean qcSourceTSL,
+    boolean publicAuthority,
+    String publicAuthorityID, 
+    boolean sscd,
+    boolean sscdSourceTSL,
+    String issuerCountryCode) {
+    SignerInfoImpl signerInfo = new SignerInfoImpl();
+    signerInfo.setSignerCertificate(signerCertificate);
+    signerInfo.setQualifiedCertificate(qualifiedCertificate);
+    signerInfo.setQCSourceTSL(qcSourceTSL);
+    signerInfo.setPublicAuthority(publicAuthority);
+    signerInfo.setPublicAuhtorityID(publicAuthorityID);
+    signerInfo.setSSCD(sscd);
+    signerInfo.setSSCDSourceTSL(sscdSourceTSL);
+    signerInfo.setIssuerCountryCode(issuerCountryCode);
+    return signerInfo;
+  }
+
+  public X509IssuerSerial createX509IssuerSerial(
+    String issuerName,
+    BigInteger serialNumber) {
+    X509IssuerSerialImpl x509IssuerSerial = new X509IssuerSerialImpl();
+    x509IssuerSerial.setX509IssuerName(issuerName);
+    x509IssuerSerial.setX509SerialNumber(serialNumber);
+    return x509IssuerSerial;
+  }
+
+}