secure_recommendations/server.cpp

Go to the documentation of this file.

/*
SeComLib
Copyright 2012-2013 TU Delft, Information Security & Privacy Lab (http://isplab.tudelft.nl/)

Contributors:
Inald Lagendijk (R.L.Lagendijk@TUDelft.nl)
Mihai Todor (todormihai@gmail.com)
Thijs Veugen (P.J.M.Veugen@tudelft.nl)
Zekeriya Erkin (z.erkin@tudelft.nl)

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

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.
*/
#include "server.h"

namespace SeComLib {
namespace SecureRecommendations {
    Server::Server (const PaillierPublicKey &key): cryptoProvider(key), clientPublicKey(key) {
        //set the kernel
        this->kernel = SecureSvm::GetKernel(Utils::Config::GetInstance().GetParameter<std::string>("SecureRecommendations.kernel"));

        //initialize other parameters
        this->contentItemCount = Utils::Config::GetInstance().GetParameter<unsigned int>("SecureRecommendations.Server.contentItemCount");
        this->blindingFactorSize = Utils::Config::GetInstance().GetParameter<unsigned int>("SecureRecommendations.Server.blindingFactorSize");
        this->modelFileExtension = Utils::Config::GetInstance().GetParameter<std::string>("SecureRecommendations.Server.modelFileExtension");

        this->medicalRelevanceModelsDirectory = Utils::Config::GetInstance().GetParameter<std::string>("SecureRecommendations.Server.MedicalRelevanceBlock.svmModelsFolder") + Utils::Config::GetInstance().GetParameter<std::string>("SecureRecommendations.kernel") + "/";
        this->medicalRelevanceClusterCount = Utils::Config::GetInstance().GetParameter<unsigned int>("SecureRecommendations.Server.MedicalRelevanceBlock.clusters");

        this->safetyModelsDirectory = Utils::Config::GetInstance().GetParameter<std::string>("SecureRecommendations.Server.SafetyBlock.svmModelsFolder") + Utils::Config::GetInstance().GetParameter<std::string>("SecureRecommendations.kernel") + "/";

        this->encryptedZero = this->cryptoProvider.GetEncryptedZero();
        this->encryptedOne = this->cryptoProvider.GetEncryptedOne();
    }

    void Server::SetClient (const std::shared_ptr<const Hub> &client) {
        this->client = client;
    }

    void Server::Initialize () {
        std::cout << "Preprocessing model files data." << std::endl;

        this->loadMedicalRelevanceSvmModels(this->medicalRelevanceModelsDirectory);

        std::cout << "Finished preprocessing data from " << this->medicalRelevanceSvms.size() << " medical relevance block model files." << std::endl;

        this->loadSafetySvmModels(this->safetyModelsDirectory);

        std::cout << "Finished preprocessing data from " << this->safetySvms.size() << " safety block model files." << std::endl;

        for (unsigned int i = 0; i < this->contentItemCount; ++i) {
            this->dummyContentItems.emplace_back((RandomProvider::GetInstance().GetRandomInteger(BigInteger(9)) + 1) * 10);
        }

        std::cout << "Finished generating dummy content items." << std::endl;

        for (unsigned int i = 0; i < this->contentItemCount; ++i) {
            this->dummyEncryptedPreferenceScores.emplace_back(this->cryptoProvider.EncryptInteger(RandomProvider::GetInstance().GetRandomInteger(BigInteger(9) + 1)));
        }

        std::cout << "Finished generating dummy preferences block scores." << std::endl;
    }

    void Server::InteractiveSecureDivision (const BigInteger &numerator, SecureSvm::EncryptedVector &denominators) const {
        std::vector<BigInteger> blindingFactors;

        for (size_t i = 0; i < denominators.size(); ++i) {
            blindingFactors.emplace_back(RandomProvider::GetInstance().GetRandomInteger(this->blindingFactorSize) + 1);

            //blind the encrypted denominators
            denominators[i] = denominators[i] * blindingFactors.back();
        }

        SecurePermutation permutation(denominators.size());
        
        permutation.Permute(denominators);

        this->client.lock()->EvaluateDivision(numerator, denominators);

        permutation.InvertPermutation(denominators);

        for (size_t i = 0; i < denominators.size(); ++i) {
            //debug kernel values
            //this->client.lock()->DebugValue(denominators[i]);

            denominators[i] = denominators[i] * blindingFactors[i];
        }
    }

    void Server::GetAccuracyPredictions (Server::EncryptedClusterVotes &clusterVotes, SecureSvm::EncryptedVector &safetyPredictions, const TestDataRow &medicalRelevanceTestData, const std::map<std::string, TestDataRow> &safetyTestData) const {
        //container for the SVM predictions (both medical relevance and safety)
        Server::EncryptedSvmValues svmPredictions;

        
        for (size_t i = 0; i < this->medicalRelevanceSvms.size(); ++i) {
            //debug
            //std::string start = Utils::DateTime::Now();
            svmPredictions.emplace_back(this->medicalRelevanceSvms[i]->Predict(medicalRelevanceTestData.x, medicalRelevanceTestData.xx, medicalRelevanceTestData.xSquared));
            //std::cout << "medical" << i << ": "; this->client.lock()->DebugValue(svmPredictions.back());
            //std::cout << "start: " << start << " end: " << Utils::DateTime::Now() << " SVM: " << i << std::endl;
        }
        
        for (size_t i = 0; i < this->safetySvms.size(); ++i) {
            std::map<std::string, TestDataRow>::const_iterator safetyTestDataIterator = safetyTestData.find(safetySvms[i]->GetUnsafeClasses());
            if (safetyTestData.end() != safetyTestDataIterator) {
                //debug
                //std::string start = Utils::DateTime::Now();
                svmPredictions.emplace_back(this->safetySvms[i]->Predict((*safetyTestDataIterator).second.x, (*safetyTestDataIterator).second.xx, (*safetyTestDataIterator).second.xSquared));
                //std::cout << safetyTestDataIterator->first << ": "; this->client.lock()->DebugValue(svmPredictions.back());
                //std::cout << "start: " << start << " end: " << Utils::DateTime::Now() << " SVM: " << i << " nSV: " << this->safetySvms[i]->model->l << std::endl;
            }
            else {
                throw std::runtime_error("Missing safety test data for unsafe classes: " + safetySvms[i]->GetUnsafeClasses());
            }
        }

        
        //overwrite the svmPredictions with the data received from the client
        this->interactiveSignEvaluation(svmPredictions);

        //debug
        /*
        for (size_t i = 0; i < svmPredictions.size(); ++i) {
            this->client.lock()->DebugValue(svmPredictions[i]);
        }
        */

        //extract and remove the safety SVM predictions from the svmPredictions vector
        std::move(svmPredictions.begin() + this->medicalRelevanceSvms.size(), svmPredictions.end(), std::back_inserter(safetyPredictions)); 
        svmPredictions.erase(svmPredictions.begin() + this->medicalRelevanceSvms.size(), svmPredictions.end());

        clusterVotes = this->getTotalClusterVotes(svmPredictions);

        
        //overwrite the clusterVotes variable
        this->interactiveMaximumEvaluation(clusterVotes);
    }

    void Server::GetPerformancePredictions (SecureSvm::EncryptedVector &firstTwoBlocksPredictions, SecureSvm::EncryptedVector &safetyPredictions, const TestDataRow &medicalRelevanceTestData, const std::map<std::string, TestDataRow> &safetyTestData) const {
        Server::EncryptedClusterVotes clusterVotes;

        this->GetAccuracyPredictions(clusterVotes, safetyPredictions, medicalRelevanceTestData, safetyTestData);

        for (unsigned long i = 0; i < this->contentItemCount; ++i) {
            //initialize the accumulator
            Paillier::Ciphertext result = this->encryptedZero;

            for (unsigned long j = 0; j < this->medicalRelevanceClusterCount; ++j) {
                //multiply the content items with the cluster votes and add the products
                result = result + clusterVotes[j] * this->dummyContentItems[i];
            }

            //combine the medical relevance and the preferences block
            firstTwoBlocksPredictions.emplace_back(result + this->dummyEncryptedPreferenceScores[i]);
        }
    }

    std::vector<std::string> Server::GetSafetyBlockSvmsUnsafeClasses () const {
        std::vector<std::string> output;

        for (size_t i = 0; i < this->safetySvms.size(); ++i) {
            output.emplace_back(this->safetySvms[i]->GetUnsafeClasses());
        }

        return output;
    }

    std::deque<std::string> Server::GetSafetyBlockModelFiles () const {
        return this->safetySvmModelFiles;
    }
    
    void Server::DebugValue (const Paillier::Ciphertext &value) const {
        this->client.lock()->DebugValue(value);
    }

    void Server::loadMedicalRelevanceSvmModels (const std::string &modelsDirectory) {
        for (unsigned int i = 0; i < this->medicalRelevanceClusterCount; ++i) {
            for (unsigned int j = i + 1; j < this->medicalRelevanceClusterCount; ++j) {
                std::stringstream fileNameBuilder;

                //construct the file path
                fileNameBuilder << "cluster" << (i + 1) << "v" << (j + 1) << "." + this->modelFileExtension;
                
                //std::unique_ptr ensures that the SecureSvm objects will not get passed by value
                this->medicalRelevanceSvms.emplace_back(std::unique_ptr<SecureSvm>(new SecureSvm(modelsDirectory, fileNameBuilder.str(), this->clientPublicKey, shared_from_this())));
            }
        }
    }

    void Server::loadSafetySvmModels (const std::string &modelsDirectory) {
        this->safetySvmModelFiles = Utils::Filesystem::GetFilesInDirectory(modelsDirectory);

        if (safetySvmModelFiles.empty()) {
            throw std::runtime_error("No model files found in directory: " + modelsDirectory);
        }

        for (std::deque<std::string>::const_iterator fileIterator = safetySvmModelFiles.begin(); fileIterator != safetySvmModelFiles.end(); ++fileIterator) {
            //std::unique_ptr ensures that the SecureSvm objects will not get passed by value
            this->safetySvms.emplace_back(std::unique_ptr<SecureSvm>(new SecureSvm(modelsDirectory, *fileIterator, this->clientPublicKey, shared_from_this())));
        }
        
    }

    Server::EncryptedClusterVotes Server::getTotalClusterVotes (EncryptedSvmValues &votes) const {
        Server::EncryptedClusterVotes clusterVotes;

        for (unsigned int i = 0; i < this->medicalRelevanceClusterCount; ++i) {
            //initialize the vote accumulator to [0]
            clusterVotes.emplace_back(this->encryptedZero);

            for (unsigned int j = 0; j < this->medicalRelevanceClusterCount; ++j) {

                //the upper right triangle of the prediction values matrix is stored as an unraveled vector
                //basically, we need to subtract sum(i - 1) = (i - 1) * i / 2 at each step to determine the index in the vector
                //also, we subtract (i + 1) at each step because we need to account for the missing SVM(i, i) values
                unsigned int index;
                
                //we don't have SVM(i, i)
                if (i != j) {
                    //upper right triangle
                    if (i < j) {
                        index = i * (medicalRelevanceClusterCount - 1) - (i - 1) * i / 2 + j - (i + 1);

                        clusterVotes[i] = clusterVotes[i] + votes[index];
                    }
                    else {
                        index = j * (medicalRelevanceClusterCount - 1) - (j - 1) * j / 2 + i - (j + 1);

                        //prediction(i, j) = 1 - prediction(j, i)
                        clusterVotes[i] = clusterVotes[i] + this->encryptedOne - votes[index];
                    }
                }
            }//i
        }//j

        return clusterVotes;
    }

    void Server::interactiveSignEvaluation (Server::EncryptedSvmValues &data) const {
        SecurePermutation permutation(data.size());
        
        permutation.Permute(data);

        for (Server::EncryptedSvmValues::iterator encryptedSvmValue = data.begin(); encryptedSvmValue != data.end(); ++encryptedSvmValue) {
            //this operation may cause an overflow on the plaintext data if the random number ends up being too large
            *encryptedSvmValue = *encryptedSvmValue * RandomProvider::GetInstance().GetRandomInteger(this->blindingFactorSize);
        }

        this->client.lock()->EvaluateSign(data);

        permutation.InvertPermutation(data);
    }

    void Server::interactiveMaximumEvaluation (Server::EncryptedClusterVotes &data) const {
        SecurePermutation permutation(data.size());
        
        permutation.Permute(data);

        BigInteger r1 = RandomProvider::GetInstance().GetRandomInteger(this->blindingFactorSize) + 1;
        Paillier::Ciphertext r2 = this->cryptoProvider.EncryptInteger(RandomProvider::GetInstance().GetRandomInteger(this->blindingFactorSize));

        for (Server::EncryptedClusterVotes::iterator encryptedClusterVote = data.begin(); encryptedClusterVote != data.end(); ++encryptedClusterVote) {
            //this operation may cause an overflow on the plaintext data if the random number ends up being too large
            *encryptedClusterVote = *encryptedClusterVote * r1 + r2;
        }

        this->client.lock()->EvaluateMaximum(data);

        permutation.InvertPermutation(data);
    }

}//namespace SecureRecommendations
}//namespace SeComLib