added DocumentService

5 files changed, 767 insertions, 0 deletions

diff --git a/DocumentService/src/eu/stork/documentservice/utils/EncryptionHelper.java b/DocumentService/src/eu/stork/documentservice/utils/EncryptionHelper.java
new file mode 100644
index 000000000..1c55e59e3
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/EncryptionHelper.java
@@ -0,0 +1,182 @@
+package eu.stork.documentservice.utils;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.security.AlgorithmParameters;
+import java.security.PublicKey;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+
+import javax.crypto.*;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+import com.sun.org.apache.xml.internal.security.utils.Base64;
+
+import eu.stork.documentservice.exceptions.EncryptionException;
+
+public class EncryptionHelper {
+	
+	private static String key;
+	private static String iv;
+	private static Cipher cipher;
+	
+	public EncryptionHelper() throws EncryptionException
+	{
+		this.generateKeys();
+	}
+	
+	public EncryptionHelper(String inKey, String inIv) throws EncryptionException
+	{
+		this.initKeys(inKey, inIv);
+	}
+	
+	/**
+	 * Generate new symmetric keys
+	 * @throws EncryptionException
+	 */
+	public void generateKeys() throws EncryptionException
+	{
+		try 
+		{
+			KeyGenerator keyGen = KeyGenerator.getInstance("AES");
+			keyGen.init(256);
+			SecretKey secretKey = keyGen.generateKey();
+			cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
+			AlgorithmParameters params = cipher.getParameters();
+			key = Base64.encode(secretKey.getEncoded());
+			iv = Base64.encode(params.getParameterSpec(IvParameterSpec.class).getIV());
+		} 
+		catch (Exception e) 
+		{				
+			e.printStackTrace();
+			throw new EncryptionException("Unable to generate encryption key.", e);
+		}		
+	}
+	
+	/**
+	 * Initialize keys with specified keys
+	 * @param inKey the key to use
+	 * @param inIv the IV to use
+	 * @throws EncryptionException the exception thrown
+	 */
+	public void initKeys(String inKey, String inIv) throws EncryptionException
+	{
+		try 
+		{
+			key = inKey;
+			iv = inIv;
+			SecretKeySpec skeySpec = new SecretKeySpec(Base64.decode(inKey), "AES");
+			cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+			cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(Base64.decode(inIv)));
+		} 
+		catch (Exception e) 
+		{				
+			e.printStackTrace();
+			throw new EncryptionException("Unable to initialize encryption key.", e);
+		}		
+	}
+	
+	/**
+	 * Encrypt data with key
+	 * @param clearData the clear data
+	 * @return the encrypted data
+	 * @throws EncryptionException the exception thrown
+	 */
+	public byte[] encrypt(byte[] clearData) throws EncryptionException
+	{		
+		if (clearData != null)
+		{
+			try
+			{
+				return cipher.doFinal(clearData);
+			}
+			catch (Exception ex)
+			{
+				throw new EncryptionException("Could not decrypt data.", ex);
+			}
+		}
+		else
+			throw new EncryptionException("Clear data is null.");
+	}
+	
+	/**
+	 * Decrypt data with keys
+	 * @param encData the encrypted data
+	 * @return decrypted data
+	 * @throws EncryptionException the exception thrown
+	 */
+	public byte[] decrypt(byte[] encData) throws EncryptionException
+	{
+		if (encData != null)
+		{
+			try
+			{
+				return cipher.doFinal(encData);
+			}
+			catch (Exception ex)
+			{
+				throw new EncryptionException("Could not encrypt data.", ex);
+			}
+		}
+		else
+			throw new EncryptionException("Encrypted data is null.");
+	}
+	
+	/**
+	 * Get the key string
+	 * @return the key
+	 */
+	public String getKey()
+	{
+		return key;
+	}
+	
+	/**
+	 * Get the IV string
+	 * @return the iv
+	 */
+	public String getIv()
+	{
+		return iv; 
+	}
+	
+	/**
+	 * Encrypt string with certificate
+	 * @param certString the PEM formated certificate
+	 * @param input the string to encrypt
+	 * @return encrypted string
+	 * @throws EncryptionException the exception thrown
+	 */
+	public String encryptWithCert(String certString, String input) throws EncryptionException
+	{
+		if (certString != null && !certString.isEmpty())
+		{
+			if (input != null && !input.isEmpty())
+			{
+				try {					
+					certString = certString.replace("-----BEGIN CERTIFICATE-----", "");
+					certString = certString.replace("-----END CERTIFICATE-----", "");
+					InputStream inStream = new ByteArrayInputStream(Base64.decode(certString));
+					CertificateFactory cf = CertificateFactory.getInstance("X.509");
+					X509Certificate cert = (X509Certificate)cf.generateCertificate(inStream);
+					PublicKey pk = cert.getPublicKey();
+					Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
+					rsaCipher.init(Cipher.ENCRYPT_MODE, pk);
+					byte[] encrypted = rsaCipher.doFinal(input.getBytes("UTF-8"));
+					return Base64.encode(encrypted);
+				} 
+				catch (Exception e) {
+					e.printStackTrace();
+					throw new EncryptionException("Unabled to encrypt string.", e);
+				}
+			}
+			else
+				throw new EncryptionException("Input is null or empty.");
+		}
+		else
+			throw new EncryptionException("Certificate is null or empty.");
+	}
+	
+}
diff --git a/DocumentService/src/eu/stork/documentservice/utils/ExternalDocservice.java b/DocumentService/src/eu/stork/documentservice/utils/ExternalDocservice.java
new file mode 100644
index 000000000..821d636a2
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/ExternalDocservice.java
@@ -0,0 +1,105 @@
+package eu.stork.documentservice.utils;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+import javax.xml.namespace.QName;
+import javax.xml.ws.BindingProvider;
+import javax.xml.ws.Service;
+import javax.xml.ws.soap.SOAPBinding;
+
+import eu.stork.documentservice.DocumentService;
+import eu.stork.documentservice.exceptions.DocumentServiceException;
+
+public class ExternalDocservice {
+	
+	/**
+	 * Get document from external DTL
+	 * @param documentTransferRequest the document transfer request (attribute query)
+	 * @param dtlUrl the URL of external DTL
+	 * @return the document found
+	 * @throws DocumentServiceException
+	 */
+	public static byte[] getDocument(String documentTransferRequest, String dtlUrl) throws DocumentServiceException
+	{
+		if (documentTransferRequest != null && !documentTransferRequest.isEmpty())
+		{								
+			if (dtlUrl != null && !dtlUrl.isEmpty())
+			{
+				try 
+				{
+					URL url = new URL(dtlUrl);					
+				  
+					QName qname = new QName("http://stork.eu",
+					    "DocumentService");
+	
+					Service service = Service.create(url, qname);
+					DocumentService docservice = service.getPort(DocumentService.class);
+					  
+					BindingProvider bp = (BindingProvider) docservice;
+				    SOAPBinding binding = (SOAPBinding) bp.getBinding();
+				    binding.setMTOMEnabled(true);
+				      
+				    return docservice.getDocument(documentTransferRequest, dtlUrl);
+				}
+				 catch (MalformedURLException e) {
+					   e.printStackTrace();
+					   throw new DocumentServiceException("DTL url is invalid.", e);
+				 }
+				catch (Exception e) {
+					e.printStackTrace();
+					   throw new DocumentServiceException(e);
+				}
+			}
+			else
+				throw new DocumentServiceException("DTL url is empty.");
+		}
+		else
+			throw new DocumentServiceException("Document transfer request is empty.");
+	}
+
+	/**
+	 * Get document mime from external DTL
+	 * @param docId the document id
+	 * @param dtlUrl the URL of external DTL
+	 * @return the document mime found
+	 * @throws DocumentServiceException
+	 */
+	public static String getDocumentMime(String docId, String dtlUrl) throws DocumentServiceException
+	{
+		if (docId != null && !docId.isEmpty())
+		{								
+			if (dtlUrl != null && !dtlUrl.isEmpty())
+			{
+				try 
+				{
+					URL url = new URL(dtlUrl);					
+				  
+					QName qname = new QName("http://stork.eu",
+					    "DocumentService");
+	
+					Service service = Service.create(url, qname);
+					DocumentService docservice = service.getPort(DocumentService.class);
+					  
+					BindingProvider bp = (BindingProvider) docservice;
+				    SOAPBinding binding = (SOAPBinding) bp.getBinding();
+				    binding.setMTOMEnabled(true);
+				      
+				    return docservice.getDocumentMime(docId, dtlUrl);
+				}
+				 catch (MalformedURLException e) {
+					   e.printStackTrace();
+					   throw new DocumentServiceException("DTL url is invalid.", e);
+				 }
+				catch (Exception e) {
+					e.printStackTrace();
+					   throw new DocumentServiceException(e);
+				}
+			}
+			else
+				throw new DocumentServiceException("DTL url is empty.");
+		}
+		else
+			throw new DocumentServiceException("Document Id is empty.");
+	}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/utils/GetDSSFileAction.java b/DocumentService/src/eu/stork/documentservice/utils/GetDSSFileAction.java
new file mode 100644
index 000000000..b80c63dc2
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/GetDSSFileAction.java
@@ -0,0 +1,84 @@
+package eu.stork.documentservice.utils;
+/*
+ * This work is Open Source and licensed by the European Commission under the
+ * conditions of the European Public License v1.1 
+ *  
+ * (http://www.osor.eu/eupl/european-union-public-licence-eupl-v.1.1); 
+ * 
+ * any use of this file implies acceptance of the conditions of this license. 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS,  WITHOUT 
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
+ * License for the specific language governing permissions and limitations 
+ * under the License.
+ */
+
+
+import org.apache.log4j.Logger;
+import org.bouncycastle.util.encoders.UrlBase64;
+
+import eu.stork.peps.auth.commons.IPersonalAttributeList;
+import eu.stork.peps.auth.commons.PEPSUtil;
+
+import eu.stork.peps.auth.commons.PersonalAttribute;
+import eu.stork.peps.auth.commons.STORKAttrQueryRequest;
+
+//import eu.stork.peps.auth.cpeps.AUCPEPS;
+import eu.stork.peps.auth.engine.STORKSAMLEngine;
+import eu.stork.peps.exceptions.STORKSAMLEngineException;
+
+/**
+ * This Action will be invoked by file transfer in order to validate saml
+ * 
+ * @author Advania
+ * 
+ * @version $Revision: $, $Date: $
+ * 
+ */
+public final class GetDSSFileAction {
+	/**
+	 * Unique identifier. 
+	 */
+	private static final long serialVersionUID = 6233180247896844849L;
+	/**
+	 * Logger object.
+	 */
+	private static final Logger LOG = Logger.getLogger(GetDSSFileAction.class.getName());
+//	public String SAMLRequest;
+//	public String docId;
+	private static final String SAML_INSTANCE = "VIDP";
+
+	public static String processDocRequest(String samlRequest)
+	{		
+		String result = "";
+	    //final Map<String, String> parameters = getHttpRequestParameters();	
+		STORKAttrQueryRequest request;
+		try {
+			request = processDocRequest_(samlRequest);
+			final IPersonalAttributeList pal = request.getPersonalAttributeList();
+		    final PersonalAttribute sdoc = pal.get("docRequest");
+		    if (sdoc != null)
+		    {
+		    	String docId = sdoc.getValue().get(0);
+		    	return docId;
+		    }
+		} catch (final STORKSAMLEngineException e) {
+			e.printStackTrace();
+		}	   		
+		return null;
+	}
+		
+	private static STORKAttrQueryRequest processDocRequest_(String samlRequest) 
+		throws STORKSAMLEngineException{
+
+			// fetch the samlToken from the request
+			final byte[] samlToken =  UrlBase64.decode(samlRequest);			
+	
+			final STORKSAMLEngine engine = STORKSAMLEngine.getInstance(SAML_INSTANCE);
+		      
+			final STORKAttrQueryRequest attrData= engine.validateSTORKAttrQueryRequest(samlToken);
+			//SAMLRequest = new String(samlToken);
+			LOG.trace("Processing doc request done. SAML: " + new String(samlToken));
+			return attrData;											
+	  }	
+}
diff --git a/DocumentService/src/eu/stork/documentservice/utils/Utils.java b/DocumentService/src/eu/stork/documentservice/utils/Utils.java
new file mode 100644
index 000000000..45072a0be
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/Utils.java
@@ -0,0 +1,172 @@
+package eu.stork.documentservice.utils;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.encoders.UrlBase64;
+
+public class Utils {
+	
+	public static boolean saveData(byte[] data, String PATH, String fileName)
+	{
+		boolean ok = false;
+		if (data != null)
+		{
+			try
+			{
+				FileOutputStream fos;
+	            File outputDir = new File(PATH);
+	            File saveFile = new File(outputDir, fileName);
+	            fos = new FileOutputStream(saveFile);
+	            fos.write(data);
+	            fos.flush();
+	            fos.close();
+	            ok = true;
+			}
+			catch (Exception e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return ok;
+	}
+	
+	public static byte[] readData(String fileName)
+	{
+		byte[] data = null;
+		
+		if (fileName != "")
+		{
+			try
+			{
+				FileInputStream fis;
+				File inputDir = new File(fileName);
+				fis = new FileInputStream(inputDir);
+				data = new byte[(int)inputDir.length()];
+				fis.read(data);
+				fis.close();
+			}
+			catch (Exception e)
+			{
+				e.printStackTrace();
+			}
+		}
+		
+		return data;
+	}
+	
+	public static String readString(String fileName)
+	{
+		File file = new File(fileName);
+		StringBuilder text = new StringBuilder();
+
+		try {
+		    BufferedReader br = new BufferedReader(new FileReader(file));
+		    String line;
+
+		    while ((line = br.readLine()) != null) {
+		        text.append(line);
+		    }
+		    br.close();
+		}
+		catch (Exception e) {
+		   e.printStackTrace();
+		}
+	    return text.toString();
+	}
+	
+	public static InputStream getStream(String string, String codePage) throws UnsupportedEncodingException
+	{
+		return new ByteArrayInputStream(string.getBytes(codePage));
+	}
+	
+	public static String encodeBase64bytes(final byte[] bytes, boolean urlSafe) {
+	      try {
+	    	  if (urlSafe)
+	    		  return new String(UrlBase64.encode(bytes), "UTF8");
+	    	  else
+	    		  return new String(Base64.encode(bytes), "UTF8");
+	      } catch (UnsupportedEncodingException e) {	          
+	          return null;
+	      }
+	  }
+	
+	public static byte[] decodeBase64String(final String base64string, boolean urlSave) {
+		if (urlSave)
+			return UrlBase64.decode(base64string);
+		else
+			return Base64.decode(base64string);
+	}
+	
+	// HTTP GET request
+	public static String sendGet(String url) throws Exception 
+	{ 
+		URL obj = new URL(url);
+		HttpURLConnection con = (HttpURLConnection) obj.openConnection();
+	 
+		// optional default is GET
+		con.setRequestMethod("GET");
+	 
+			//add request header
+		con.setRequestProperty("User-Agent", "unknown");
+	 
+		//int responseCode = con.getResponseCode();
+		
+		BufferedReader in = new BufferedReader(
+				new InputStreamReader(con.getInputStream()));
+		String inputLine;
+		StringBuffer response = new StringBuffer();
+	 
+		while ((inputLine = in.readLine()) != null) {
+			response.append(inputLine);
+		}
+		in.close();
+	 
+		return response.toString();
+	 
+		}
+	 
+		// HTTP POST request
+		public static String sendPost(String url, String urlParameters) throws Exception
+		{
+	 		URL obj = new URL(url);
+			HttpURLConnection con = (HttpURLConnection) obj.openConnection();
+	 
+			//add request header
+			con.setRequestMethod("POST");
+			con.setRequestProperty("User-Agent", "unknown");
+			con.setRequestProperty("Accept-Language", "en-US,en;q=0.5");
+	 
+			// Send post request
+			con.setDoOutput(true);
+			DataOutputStream wr = new DataOutputStream(con.getOutputStream());
+			wr.writeBytes(urlParameters);
+			wr.flush();
+			wr.close();
+	 
+			//int responseCode = con.getResponseCode();
+				 
+			BufferedReader in = new BufferedReader(
+			        new InputStreamReader(con.getInputStream()));
+			String inputLine;
+			StringBuffer response = new StringBuffer();
+	 
+			while ((inputLine = in.readLine()) != null) {
+				response.append(inputLine);
+			}
+			in.close();
+	 
+			return response.toString();
+		}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/utils/XmlHelper.java b/DocumentService/src/eu/stork/documentservice/utils/XmlHelper.java
new file mode 100644
index 000000000..cd325db2e
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/XmlHelper.java
@@ -0,0 +1,224 @@
+package eu.stork.documentservice.utils;
+
+import java.io.InputStream;
+import java.util.Properties;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Node;
+import org.w3c.dom.Element;
+
+//import at.gv.egovernment.moa.id.protocols.stork2.attributeproviders.GetDSSFileAction;
+
+import eu.stork.documentservice.data.DatabaseConnectorMySQLImpl;
+import eu.stork.documentservice.exceptions.DocumentServiceException;
+
+public class XmlHelper {
+	
+	private static Properties props = new Properties();
+	
+	public static String getRequestId(String xmlRequest) throws DocumentServiceException
+	{
+		if (xmlRequest == null || xmlRequest.isEmpty())
+			throw new DocumentServiceException("XML request is empty");
+		else
+		{
+			try
+			{
+				InputStream is = Utils.getStream(xmlRequest, "UTF-8");
+				DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance()
+	                    .newDocumentBuilder();
+				Document doc = dBuilder.parse(is);
+				Element reqElement = doc.getDocumentElement();
+				String reqId = reqElement.getAttribute("RequestID"); 
+				return reqId.replace("_", "");
+			}
+			catch (Exception ex)
+			{
+				throw new DocumentServiceException("Unabled to parse xml.", ex);
+			}
+		}
+	}
+	
+	public static String getRequestDocument(String xmlRequest) throws DocumentServiceException
+	{
+		if (xmlRequest == null || xmlRequest.isEmpty())
+			throw new DocumentServiceException("XML request is empty");
+		else
+		{
+			try
+			{
+				InputStream is = Utils.getStream(xmlRequest, "UTF-8");
+				DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance()
+	                    .newDocumentBuilder();
+				Document doc = dBuilder.parse(is);
+				String document = "";
+				Element req = doc.getDocumentElement();
+				NodeList nList0 = req.getChildNodes();
+				for (int i = 0; i < nList0.getLength(); i++)
+				{
+					Node node = nList0.item(i);
+					NodeList nList1 = node.getChildNodes();
+					for (int j = 0; j < nList1.getLength(); j++)
+					{
+						NodeList nList2 = nList1.item(j).getChildNodes();
+						for (int k = 0; k < nList2.getLength(); k++)
+						{
+							Node docNode =nList2.item(k);
+							document = docNode.getTextContent();
+						}
+					}
+				}
+				return document;
+			}
+			catch (Exception ex)
+			{
+				throw new DocumentServiceException("Unabled to parse xml.", ex);
+			}
+		}
+	}
+	
+	public static String getRequestDocumentData(String xmlRequest) throws DocumentServiceException
+	{
+		if (xmlRequest == null || xmlRequest.isEmpty())
+			throw new DocumentServiceException("XML request is empty");
+		else
+		{
+			try
+			{
+				InputStream is = Utils.getStream(xmlRequest, "UTF-8");
+				DocumentBuilderFactory xmlFactory = DocumentBuilderFactory.newInstance();
+				DocumentBuilder docBuilder = xmlFactory.newDocumentBuilder();
+				Document xmlDoc = docBuilder.parse(is);
+				XPathFactory xpathFact = XPathFactory.newInstance();
+				XPath xpath = xpathFact.newXPath();
+				return xpath.evaluate("/SignRequest/InputDocuments/Document/Base64Data/text()", xmlDoc);				
+				
+			}
+			catch (Exception ex)
+			{
+				throw new DocumentServiceException("Unabled to parse xml.", ex);
+			}
+		}
+	}
+	
+	public static String getRequestDocumentMime(String xmlRequest) throws DocumentServiceException
+	{
+		if (xmlRequest == null || xmlRequest.isEmpty())
+			throw new DocumentServiceException("XML request is empty");
+		else
+		{
+			try
+			{
+				InputStream is = Utils.getStream(xmlRequest, "UTF-8");
+				DocumentBuilderFactory xmlFactory = DocumentBuilderFactory.newInstance();
+				DocumentBuilder docBuilder = xmlFactory.newDocumentBuilder();
+				Document xmlDoc = docBuilder.parse(is);
+				XPathFactory xpathFact = XPathFactory.newInstance();
+				XPath xpath = xpathFact.newXPath();
+				return xpath.evaluate("/SignRequest/InputDocuments/Document/Base64Data/@MimeType", xmlDoc);				
+				
+			}
+			catch (Exception ex)
+			{
+				throw new DocumentServiceException("Unabled to parse xml.", ex);
+			}
+		}
+	}
+	
+	private static String getDocId(String response) throws DocumentServiceException
+	{
+		if (response == null || response.isEmpty())
+			throw new DocumentServiceException("Response is empty");
+		else
+		{
+			if (response.contains("docId"))
+			{
+				int index = response.indexOf("docId");
+				String docText = response.substring(response.indexOf(">" ,index), response.indexOf("<", index));
+				String docId = docText.replaceAll("[<>]", "");	//s:label name="docId" value="%{docId}"/			
+				docId = docId.substring(docId.indexOf("/")+1);
+				docId = docId.substring(docId.indexOf('/')+1);
+				return docId.replace("/", "");
+			}
+			else
+				throw new DocumentServiceException("No document ID in response.");
+		}
+	}
+	
+	/**
+	 * String the document id
+	 * @param docId the document id to strip
+	 * @return the stripped ID
+	 * @throws DocumentServiceException
+	 */
+	public static String StripDocId(String docId) throws DocumentServiceException
+	{
+		if (docId == null || docId.isEmpty())
+			throw new DocumentServiceException("Doc ID is empty");
+		else
+		{
+			docId = docId.substring(docId.indexOf("/")+1);
+			docId = docId.substring(docId.indexOf('/')+1);
+			return docId.replace("/", "");
+		}
+	}
+	
+	public static String verifyRequest(String transferRequest) throws DocumentServiceException
+	{
+		if (transferRequest == null || transferRequest.isEmpty())
+			throw new DocumentServiceException("Transfer request is empty");
+		else
+		{			
+			try {		
+				String docId="";
+				try{
+				
+//				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));	
+//				System.out.println("url:"+props.getProperty("peps.url"));
+				
+//				final byte[] samlToken =  PEPSUtil.decodeSAMLTokenUrlSafe(parameters
+//						.get(PEPSParameters.SAML_REQUEST.toString()));			
+//			
+//					final STORKSAMLEngine engine = STORKSAMLEngine.getInstance("VIDP");
+//				      
+//					final STORKAttrQueryRequest attrData= engine.validateSTORKAttrQueryRequest(samlToken);
+					
+//				String response = Utils.sendPost(props.getProperty("peps.url"), "SAMLRequest=" + transferRequest);
+//				docId=getDocId(response);;
+				docId = GetDSSFileAction.processDocRequest(transferRequest);
+				}catch(Exception e){e.printStackTrace();}
+				return docId;
+				//FIXME
+//				String response = Utils.sendPost(props.getProperty("peps.url"), "SAMLRequest=" + transferRequest);
+//				return getDocId(response);
+			} catch (Exception e) {
+				e.printStackTrace();
+				throw new DocumentServiceException("Could verify request.", e);
+			} 
+		}
+	}
+	
+	public static String verifyRequestByte(byte[] transferRequest) throws DocumentServiceException
+	{
+		if (transferRequest == null)
+			throw new DocumentServiceException("Transfer request is empty");
+		else
+		{			
+			try {				
+				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+				String response = Utils.sendPost(props.getProperty("peps.url"),"SAMLRequest=" + Utils.encodeBase64bytes(transferRequest, true));
+				return getDocId(response);
+			} catch (Exception e) {
+				e.printStackTrace();
+				throw new DocumentServiceException("Could not read properties.", e);
+			}
+	
+		}
+	}
+}