Homec4science
Diffusion Genome Privacy - SHCS App (downgrade_java6) Browse

genopri-shcs/project/PPPServer/src/framework/RequestHandler.java
09691ea9bb9edowngrade_java6

Last Change
Raw File

RequestHandler.java
View Options

package framework;
import framework.reply.ReplyDecryption;
import framework.reply.ReplyDecryptionRaw;
import framework.reply.ReplyMaterial;
import framework.request.RequestDecryption;
import framework.request.RequestDecryptionRaw;
import framework.request.RequestMaterial;
import framework.test.TestResultEncoded;
import framework.test.TestResultPartialEncoded;
import io.serializer.url.URLParserDecrypt;
import io.serializer.url.URLParserMaterial;
import io.serializer.xml.XMLParserDecrypt;
import io.serializer.xml.XMLParserMaterial;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.json.JSONException;
import crypto.elgamal.ECElGamal;
import crypto.elgamal.PartialSecret;
import crypto.elgamal.fragment.FragmentEncoded;
import crypto.elgamal.fragment.FragmentEncrypted;
import crypto.elgamal.fragment.FragmentPartial;
import crypto.elgamal.fragment.FragmentPartialEncoded;
import database.DBconnectorServer;
import database.DBconnectorServerStandalone;
public class RequestHandler {
private static final Logger LOGGER = Logger.getLogger(RequestHandler.class.getName());
private DBconnectorServer connectServer;
private String curveName;
public RequestHandler(DBconnectorServer connectServer, String curveName) {
this.connectServer = connectServer;
this.curveName = curveName;
}
public String handleMaterialRequest(String requestLine) throws JSONException, SQLException, IOException {
// parse line for request
RequestMaterial rqt = URLParserMaterial.stringToRequest(requestLine);
int patientId = rqt.getPatientId();
LOGGER.log(Level.FINE, "patient " + patientId);
LinkedList<MarkerEncrypted> requiredMarkers = rqt.getRequiredMarkers();
LinkedList<MarkerEncrypted> requiredCFs = rqt.getRequiredCFs();
// add encoded markers to reply
LinkedList<FragmentEncoded> encodedMarkers = retrieveEncodedMarkers(patientId, requiredMarkers);
// add encoded clinical factors to reply
LinkedList<FragmentEncoded> encodedCFs = retrieveEncodedCFs(patientId, requiredCFs);
// add encoded HLAs
ArrayList<LinkedList<FragmentEncoded>> encodedHLAs = retrieveEncodedHLAs(patientId);
// prepare response
ReplyMaterial replyMaterial = new ReplyMaterial(patientId, encodedMarkers, encodedCFs, encodedHLAs);
// send result
String replyString = (new XMLParserMaterial()).replyToString(replyMaterial);
return replyString;
}
public ReplyDecryptionRaw handleDecryptionRequestParsed(int patientId, long timestamp, String requestSerialized) throws SQLException, IOException {
RequestDecryption rqt = URLParserDecrypt.convertBase64ToRequest(requestSerialized, patientId, timestamp);
ReplyDecryption reply = processDecryption(rqt);
String replySerialized = XMLParserDecrypt.convertReplyToBase64(reply);
return new ReplyDecryptionRaw(reply.getPatientId(), reply.getTimestamp(), replySerialized);
}
public String handleDecryptionStandalone(String requestLine, DBconnectorServerStandalone connectSA) throws SQLException, InterruptedException, IOException {
RequestDecryptionRaw requestRaw = URLParserDecrypt.stringToRequestRaw(requestLine);
int patientId = requestRaw.getPatientId();
long timestamp = requestRaw.getTimestamp();
System.out.println(timestamp);
connectSA.insertRequest(requestRaw);
ReplyDecryptionRaw reply = null;
do {
Thread.sleep(1000L);
reply = connectSA.getReply(patientId, timestamp);
} while (reply == null);
String replyString = (new XMLParserDecrypt()).replyRawToString(reply);
return replyString;
}
public String handleDecryptionRequest(String requestLine) throws JSONException, SQLException, IOException {
// parse line for request
RequestDecryption rqt = URLParserDecrypt.stringToRequest(requestLine);
ReplyDecryption reply = processDecryption(rqt);
// send result
String replyString = (new XMLParserDecrypt()).replyToString(reply);
return replyString;
}
private ReplyDecryption processDecryption(RequestDecryption rqt) throws SQLException, IOException {
int patientId = rqt.getPatientId();
LOGGER.log(Level.FINE, "patient " + patientId);
LinkedList<TestResultEncoded> testResults = rqt.getEncodedResults();
ArrayList<LinkedList<FragmentEncoded>> encodedHLAs = rqt.getEncodedHLAs();
ECElGamal ecceg = getScheme(patientId);
// decrypt values
LinkedList<TestResultPartialEncoded> partialEncResults = decryptTestResults(ecceg, testResults);
ArrayList<LinkedList<FragmentPartialEncoded>> partialEncHLAs = decryptHLAs(ecceg, encodedHLAs);
// package result
ReplyDecryption reply = new ReplyDecryption(patientId, partialEncResults, partialEncHLAs);
reply.setTimestamp(rqt.getTimestamp());
return reply;
}
private ArrayList<LinkedList<FragmentPartialEncoded>> decryptHLAs(
ECElGamal ecceg, ArrayList<LinkedList<FragmentEncoded>> encodedHLAs) {
ArrayList<LinkedList<FragmentPartialEncoded>> partialHLAs = new ArrayList<>();
for (LinkedList<FragmentEncoded> listHLA : encodedHLAs) {
LinkedList<FragmentPartialEncoded> partials = new LinkedList<>();
for (FragmentEncoded fragEncoded : listHLA) {
FragmentEncrypted encrypted = fragEncoded.decodeFragment(ecceg);
FragmentPartial partial = ecceg.partialDecrypt(encrypted);
partials.add(partial.getFragmentPartialEncoded());
}
partialHLAs.add(partials);
}
return partialHLAs;
}
private LinkedList<TestResultPartialEncoded> decryptTestResults(
ECElGamal ecceg, LinkedList<TestResultEncoded> testResults) {
LinkedList<TestResultPartialEncoded> results = new LinkedList<>();
for (TestResultEncoded testEnc : testResults) {
if (testEnc != null) {
results.add(testEnc.getTestPartialEncoded(ecceg));
} else {
results.add(null);
}
}
return results;
}
private ECElGamal getScheme(int patientId) throws SQLException {
ECElGamal ecceg = new ECElGamal(curveName);
// load private key into ECCEG
PartialSecret partialSecret = connectServer.getPrivateKey(patientId);
ecceg.setSecretShare(partialSecret);
return ecceg;
}
private LinkedList<FragmentEncoded> retrieveEncodedMarkers(
int patientId, LinkedList<MarkerEncrypted> requiredMarkers) throws SQLException {
LinkedList<FragmentEncoded> encodedMarkers = new LinkedList<>();
connectServer.openConnection();
for (MarkerEncrypted markerEnc : requiredMarkers) {
FragmentEncoded frag = connectServer.getEncodedSNP(patientId, markerEnc);
encodedMarkers.add(frag);
}
connectServer.closeConnection();
return encodedMarkers;
}
private LinkedList<FragmentEncoded> retrieveEncodedCFs(int patientId,
LinkedList<MarkerEncrypted> requiredCFs) throws SQLException {
LinkedList<FragmentEncoded> encodedCFs = new LinkedList<>();
connectServer.openConnection();
for (MarkerEncrypted markerEnc : requiredCFs) {
FragmentEncoded frag = connectServer.getEncodedCF(patientId, markerEnc);
encodedCFs.add(frag);
}
connectServer.closeConnection();
return encodedCFs;
}
private ArrayList<LinkedList<FragmentEncoded>> retrieveEncodedHLAs(int id_p) throws SQLException, IOException {
connectServer.openConnection();
ArrayList<LinkedList<FragmentEncoded>> encodedHLAs = connectServer.getHLA(id_p);
connectServer.closeConnection();
return encodedHLAs;
}
}
c4science · Help