Diffusion Genome Privacy - SHCS App (master) Browse

ClinicalEngine.java
4474a01cc319master

ClinicalEngine.java
View Options

			package ch.epfl.pharma.framework;

			import framework.ClinicalFactor;
			import framework.DiagnosticRaw;
			import framework.Marker;
			import framework.MissingMaterialException;
			import framework.TestMaterial;
			import framework.WeightedMarker;
			import framework.reply.ReplyDecryption;
			import framework.reply.ReplyMaterial;
			import framework.request.RequestDecryption;
			import framework.request.RequestMaterial;
			import framework.test.TestResultEncrypted;
			import framework.test.TestResultPartialEncoded;
			import framework.test.TestResultRaw;
			import io.CommAdapter;

			import java.io.IOException;
			import java.math.BigInteger;
			import java.sql.SQLException;
			import java.util.ArrayList;
			import java.util.Collections;
			import java.util.HashMap;
			import java.util.HashSet;
			import java.util.LinkedList;
			import java.util.Set;
			import java.util.logging.Level;
			import java.util.logging.Logger;

			import org.spongycastle.math.ec.ECPoint;

			import utils.CollectionUtils;
			import android.annotation.SuppressLint;
			import ch.epfl.pharma.database.DatabaseHelper;
			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;

			public class ClinicalEngine {

			private static final Logger LOGGER = Logger.getLogger(ClinicalEngine.class.getName());

			// default values
			private BigInteger shiftVal = BigInteger.valueOf(1000);
			private int precision = 100;

			// patient id
			private int patientId;

			// crypto engine
			private ECElGamal cryptoEng = null;

			// communication adapters
			private DatabaseHelper connDBMU = null;
			private CommAdapter commAdapter = null;

			public ClinicalEngine(int patientId, DatabaseHelper connDBMU, CommAdapter commAdapter) {
			this.patientId = patientId;
			this.connDBMU = connDBMU;
			this.commAdapter = commAdapter;
			}

			/**
			* Retrieve ECCEG module for a given patient.
			* Load public and local secret share of client.
			* Load lookup table from disk.
			*
			* @param patientId
			* @return
			* @throws SQLException
			*/
			public boolean loadCryptoEngine(String curveName, HashMap<ECPoint, BigInteger> reverseTable) {
			cryptoEng = new ECElGamal(curveName);

			// open connection
			connDBMU.openDatabase();

			ECPoint pPubKey = null;
			PartialSecret partialSecret = null;

			// get public key ECCEG
			pPubKey = connDBMU.getPublicKey(patientId, cryptoEng.getECParams());

			// get private key ECCEG
			partialSecret = connDBMU.getPrivateKey(patientId);

			// close connection
			// connDBMU.close();

			// load keys in crypto engine
			cryptoEng.setpPubKey(pPubKey);
			cryptoEng.setSecretShare(partialSecret);

			// load reverse table
			cryptoEng.setReverseTable(reverseTable);

			return true;
			}

			public TestMaterial getMaterial(HashSet<Marker> requiredMarkers,
			HashSet<Integer> requiredCFs) {

			// prepare material request
			LinkedList<Marker> markersSorted = new LinkedList<>(requiredMarkers);
			Collections.sort(markersSorted);
			LinkedList<Integer> cfsSorted = new LinkedList<>(requiredCFs);
			Collections.sort(cfsSorted);

			RequestMaterial rqtMaterial = new RequestMaterial(patientId, markersSorted, cfsSorted);

			// send request and get result
			ReplyMaterial replyMaterial = commAdapter.callServiceMaterial(rqtMaterial);

			// remap markers and cfs to identifiers
			LinkedList<FragmentEncrypted> markerValues = replyMaterial.convertToEncryptedMarkers(cryptoEng);
			HashMap<Marker, FragmentEncrypted> markers = CollectionUtils.mapLists(markersSorted, markerValues);

			LinkedList<FragmentEncrypted> cfValues = replyMaterial.convertToEncryptedCFs(cryptoEng);
			HashMap<Integer, FragmentEncrypted> cfs = CollectionUtils.mapLists(cfsSorted, cfValues);

			// package material
			TestMaterial material = new TestMaterial();
			material.setEncryptedSNPs(markers);
			material.setEncryptedCFs(cfs);
			material.setEncodedHLAs(replyMaterial.getEncodedHLAs());

			return material;
			}

			public HashMap<Integer, TestResultEncrypted> computeTests(Set<Integer> requiredTestIds,
			TestMaterial material,
			HashMap<Integer, ArrayList<WeightedMarker>> weightedMarkers,
			HashMap<Integer, ArrayList<ClinicalFactor>> clinicalFactors) {

			HashMap<Integer, TestResultEncrypted> results = new HashMap<>();

			for (Integer testId : requiredTestIds) {
			TestResultEncrypted resultRaw = computeTest(material, weightedMarkers.get(testId), clinicalFactors.get(testId));
			results.put(testId, resultRaw);
			}
			return results;
			}

			/**
			* DEPRECATED
			* Compute a genomic test.
			*
			* All operations in Cipher Space.
			* Sum all weighted SNPs.
			* Sum all weighted Clinical Factors.
			*
			* First element of result is the sum of SNPs only.
			* Second element of result is the sum of both SNPs and CFs.
			*
			* @param ecceg
			* @param markers
			* @param reverseDecMap
			* @param encodedSNPs
			* @param clinicalFactors
			* @param encodedCFs
			* @return
			* first element: score purely genetic (SNP)
			* second element: score genetic with clinical factors (SNP + CF)
			*/
			private TestResultEncrypted computeTest(TestMaterial material,
			ArrayList<WeightedMarker> weightedMarkers,
			ArrayList<ClinicalFactor> weightedClinicalFactors) {

			FragmentEncrypted sumSNPs = null;
			FragmentEncrypted sumCFs = null;

			try {
			sumSNPs = weightedSumSNPs(weightedMarkers, material.getEncryptedSNPs());
			sumCFs = weightedSumCFs(weightedClinicalFactors, material.getEncryptedCFs());
			} catch (MissingMaterialException e) {
			LOGGER.log(Level.WARNING, e.getMessage());
			return null;
			}

			// avoid negative values for tests
			FragmentEncrypted tradeoff = cryptoEng.encrypt(shiftVal);

			// compute genomic result
			FragmentEncrypted resultGenomic = sumSNPs.add(tradeoff);

			// compute clinical result
			FragmentEncrypted resultClinical = null;
			if (sumCFs != null) {
			resultClinical = sumSNPs.add(sumCFs).add(tradeoff);
			}

			// package results in TestResultEncrypted
			return new TestResultEncrypted(resultGenomic, resultClinical);
			}

			private FragmentEncrypted weightedSumCFs(
			ArrayList<ClinicalFactor> weightedClinicalFactors,
			HashMap<Integer, FragmentEncrypted> encryptedCFs) throws MissingMaterialException {

			if (weightedClinicalFactors.isEmpty()) {
			return null;
			}

			FragmentEncrypted sumCFs = cryptoEng.getNullFragment();

			for (ClinicalFactor clinicalFactor : weightedClinicalFactors) {
			FragmentEncrypted currentCF = encryptedCFs.get(clinicalFactor.getClinicalFactorId());

			if (currentCF != null) {
			double weightDouble = clinicalFactor.getWeight();

			//particular case for AGE clinical factor AGE_score = (Age-45)*w/5
			if (clinicalFactor.getClinicalFactorId() == 2) {
			// shift age. age_0 = 45 y.o.
			// FIXME check if this is correct
			FragmentEncrypted shiftAge = cryptoEng.encrypt(BigInteger.valueOf(-45));
			currentCF = currentCF.add(shiftAge);
			weightDouble = weightDouble / 5;
			}

			BigInteger weight = BigInteger.valueOf(Math.round(weightDouble * precision));
			FragmentEncrypted weightedCF = currentCF.scale(weight);

			sumCFs = sumCFs.add(weightedCF);
			}
			else { // discard CF entry
			throw new MissingMaterialException("No clinical factor found in database", clinicalFactor.getClinicalFactorId().toString());
			}
			}

			return sumCFs;
			}

			private FragmentEncrypted weightedSumSNPs(
			ArrayList<WeightedMarker> weightedMarkers,
			HashMap<Marker, FragmentEncrypted> encryptedSNPs) throws MissingMaterialException {

			FragmentEncrypted sumSNPs = cryptoEng.getNullFragment();

			for (WeightedMarker marker : weightedMarkers) {
			FragmentEncrypted currentSNP = encryptedSNPs.get(marker.getMarker());
			if (currentSNP != null) {
			BigInteger weight = BigInteger.valueOf(Math.round(marker.getWeight() * precision));
			FragmentEncrypted weightedSNP = currentSNP.scale(weight);

			sumSNPs = sumSNPs.add(weightedSNP);
			}
			else { // discard SNP entry
			throw new MissingMaterialException("No SNP entry found in database", marker.getMarker().toString());
			}
			}

			return sumSNPs;
			}

			/**
			* Decrypts the encrypted susceptibility computed by the SPU.
			*/
			private double decryptionTest(FragmentPartial partial) {
			return cryptoEng.fullyDecrypt(partial).subtract(shiftVal).doubleValue() / precision;
			}

			private String decryptHLA(FragmentPartial partial) {
			BigInteger val = cryptoEng.fullyDecrypt(partial);
			return fmt4Digits(val);
			}

			public DiagnosticRaw decryptDiagnostic(
			HashMap<Integer, TestResultEncrypted> encryptedResults,
			ArrayList<LinkedList<FragmentEncoded>> encodedHLAs) throws IOException {

			// prepare decryption request
			// sort testIds
			LinkedList<TestResultEncrypted> encryptedResultsList = new LinkedList<>();
			LinkedList<Integer> testIndices = new LinkedList<>(encryptedResults.keySet());
			Collections.sort(testIndices);
			for (Integer testIndex : testIndices) {
			encryptedResultsList.add(encryptedResults.get(testIndex));
			}

			RequestDecryption rqtDecrypt = new RequestDecryption(patientId, encodedHLAs, encryptedResultsList);
			rqtDecrypt.setTimestamp(System.currentTimeMillis());

			// send request and get result
			ReplyDecryption replyDecrypt = commAdapter.callServiceDecrypt(rqtDecrypt);

			// reassemble results into hashmap
			LinkedList<TestResultPartialEncoded> partialResultsList = replyDecrypt.getPartialEncResults();
			HashMap<Integer, TestResultPartialEncoded> partialResults = new HashMap<>();
			for (int i = 0; i < partialResultsList.size(); i++) {
			partialResults.put(testIndices.get(i), partialResultsList.get(i));
			}

			// unpackage results
			HashMap<Integer, TestResultRaw> testResultsRaw = decryptTestResults(partialResults);
			ArrayList<LinkedList<String>> hlas = decryptHLAs(replyDecrypt.getPartialEncHLAs());
			String[] hlaA = CollectionUtils.castStringArray(hlas.get(0).toArray());
			String[] hlaB = CollectionUtils.castStringArray(hlas.get(1).toArray());
			String[] hlaC = CollectionUtils.castStringArray(hlas.get(2).toArray());

			DiagnosticRaw diag = new DiagnosticRaw(testResultsRaw, hlaA, hlaB, hlaC);

			return diag;
			}

			// FIXME check with previous version for size()>1 how it behaves
			private ArrayList<LinkedList<String>> decryptHLAs(
			ArrayList<LinkedList<FragmentPartialEncoded>> partialEncHLAs) {
			ArrayList<LinkedList<String>> hlas = new ArrayList<>();

			for (LinkedList<FragmentPartialEncoded> listPartials : partialEncHLAs) {
			LinkedList<String> listHLA = new LinkedList<>();
			for (FragmentPartialEncoded partialEnc : listPartials) {
			listHLA.add(decryptHLA(partialEnc.decodeFragment(cryptoEng)));
			}

			hlas.add(listHLA);
			}

			return hlas;
			}

			private HashMap<Integer, TestResultRaw> decryptTestResults(
			HashMap<Integer, TestResultPartialEncoded> partialEncResults) {

			HashMap<Integer, TestResultRaw> results = new HashMap<>();

			for (Integer testId : partialEncResults.keySet()) {
			TestResultPartialEncoded testPartial = partialEncResults.get(testId);
			TestResultRaw resultRaw;

			if (testPartial != null) {
			// decrypt result genomic
			double resultGenomic = decryptionTest(testPartial.getGenomic(cryptoEng));

			// decrypt result clinical if present
			FragmentPartial partialClinical = testPartial.getClinical(cryptoEng);
			if (partialClinical == null) {
			resultRaw = new TestResultRaw(resultGenomic);
			}
			else {
			double resultClinical = decryptionTest(testPartial.getClinical(cryptoEng));
			resultRaw = new TestResultRaw(resultGenomic, resultClinical);
			}
			} else {
			resultRaw = null;
			}

			results.put(testId, resultRaw);
			}

			return results;
			}

			@SuppressLint("DefaultLocale")
			private String fmt4Digits(BigInteger num) {
			return String.format("%04d", num.intValue());
			}
			}

genopri-shcs/project/PPPClientMobile/src/ch/epfl/pharma/framework/ClinicalEngine.java4474a01cc319master

ClinicalEngine.javaView Options

genopri-shcs/project/PPPClientMobile/src/ch/epfl/pharma/framework/ClinicalEngine.java
4474a01cc319master

ClinicalEngine.java
View Options