Homec4science
Diffusion Genome Privacy - SHCS App (mobile_app) Browse

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

Last Change
Raw File

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());
}
}
c4science · Help