Program Listing for File gen-cryptocontext-params.h
↰ Return to documentation for file (pke/include/scheme/gen-cryptocontext-params.h)
//==================================================================================
// BSD 2-Clause License
//
// Copyright (c) 2014-2022, NJIT, Duality Technologies Inc. and other contributors
//
// All rights reserved.
//
// Author TPOC: contact@openfhe.org
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//==================================================================================
/*
Scheme parameter default class
*/
#ifndef __GEN_CRYPTOCONTEXT_PARAMS_H__
#define __GEN_CRYPTOCONTEXT_PARAMS_H__
#include "scheme/scheme-id.h"
#include "utils/inttypes.h"
#include "constants.h"
#include "lattice/constants-lattice.h"
#include "lattice/stdlatticeparms.h"
#include <iosfwd>
#include <string>
#include <vector>
namespace lbcrypto {
//====================================================================================================================
class Params {
// NOTE: if any data member (below) is added/removed then update
// cryptocontextparams-case.cpp and cryptocontextparams-defaults.h
// Scheme ID
SCHEME scheme;
// PlaintextModulus ptModulus is used in BGV/BFV type schemes and impacts noise growth
PlaintextModulus ptModulus;
// digitSize is used in BV Key Switching only (KeySwitchTechnique = BV) and impacts noise growth
uint32_t digitSize;
// standardDeviation is used for Gaussian error generation
float standardDeviation;
// Secret key distribution: GAUSSIAN, UNIFORM_TERNARY, etc.
SecretKeyDist secretKeyDist;
// Max relinearization degree of secret key polynomial (used for lazy relinearization)
uint32_t maxRelinSkDeg;
// key switching technique: BV or HYBRID currently
// For BV we do not have extra modulus, so the security depends on ciphertext modulus Q.
// For HYBRID we do have extra modulus P, so the security depends on modulus P*Q
// For BV we need digitSize - digit size in digit decomposition
// For HYBRID we need numLargeDigits - number of digits in digit decomposition
// it is good to have alternative to numLargeDigits (possibly numPrimesInDigit?)
KeySwitchTechnique ksTech;
// rescaling/modulus switching technique used in CKKS/BGV: FLEXIBLEAUTOEXT, FIXEDMANUL, FLEXIBLEAUTO, etc.
// see https://eprint.iacr.org/2022/915 for details
ScalingTechnique scalTech;
// max batch size of messages to be packed in encoding (number of slots)
uint32_t batchSize;
// PRE security mode
ProxyReEncryptionMode PREMode;
// Multiparty security mode in BFV/BGV
// NOISE_FLOODING_MULTIPARTY is more secure than FIXED_NOISE_MULTIPARTY.
MultipartyMode multipartyMode;
// Execution mode in CKKS
// In EXEC_NOISE_ESTIMATION mode, we estimate the noise we need to add to the actual computation to guarantee good security.
// In EXEC_EVALUATION mode, we input our noise estimate and perform the desired secure encrypted computation.
ExecutionMode executionMode;
// Decryption noise mode in CKKS
// NOISE_FLOODING_DECRYPT is more secure than FIXED_NOISE_DECRYPT, but it requires executing all computations twice.
DecryptionNoiseMode decryptionNoiseMode;
// Noise estimate in CKKS for NOISE_FLOODING_DECRYPT mode.
// This estimate is obtained from running the computation in EXEC_NOISE_ESTIMATION mode.
double noiseEstimate;
// Desired precision for 128-bit CKKS. We use this value in NOISE_FLOODING_DECRYPT mode to determine the scaling factor.
double desiredPrecision;
// Statistical security of CKKS in NOISE_FLOODING_DECRYPT mode. This is the bound on the probability of success
// that any adversary can have. Specifically, they a probability of success of at most 2^(-statisticalSecurity).
uint32_t statisticalSecurity;
// This is the number of adversarial queries a user is expecting for their application, which we use to ensure
// security of CKKS in NOISE_FLOODING_DECRYPT mode.
uint32_t numAdversarialQueries;
// This is the number of parties in a threshold application, which is used for bound on the joint secret key
uint32_t thresholdNumOfParties;
// firstModSize and scalingModSize are used to calculate ciphertext modulus. The ciphertext modulus should be seen as:
// Q = q_0 * q_1 * ... * q_n * q'
// where q_0 is first prime, and it's number of bits is firstModSize
// other q_i have same number of bits and is equal to scalingModSize
// the prime q' is not explicitly given,
// but it is used internally in CKKS and BGV schemes (in *EXT scaling methods)
uint32_t firstModSize;
uint32_t scalingModSize;
// see KeySwitchTechnique - number of digits in HYBRID key switching
uint32_t numLargeDigits;
// multiplicative depth
uint32_t multiplicativeDepth;
// security level:
// We use the values from the security standard at
// http://homomorphicencryption.org/wp-content/uploads/2018/11/HomomorphicEncryptionStandardv1.1.pdf
// For given ring dimension and security level we have
// upper bound of possible highest modulus (Q for BV or P*Q for HYBRID)
SecurityLevel securityLevel;
// ring dimension N of the scheme : the ring is Z_Q[x] / (X^N+1)
uint32_t ringDim;
// number of additions (used for setting noise in BGV and BFV)
uint32_t evalAddCount;
// number of key switching operations (used for setting noise in BGV and BFV)
uint32_t keySwitchCount;
// size of moduli used for PRE in the provable HRA setting
uint32_t PRENumHops;
// STANDARD or EXTENDED mode for BFV encryption
// EXTENDED slightly reduces the size of Q (by few bits) but makes encryption somewhat slower
// see https://eprint.iacr.org/2022/915 for details
EncryptionTechnique encryptionTechnique;
// multiplication method in BFV: BEHZ, HPS, etc.
// see https://eprint.iacr.org/2022/915 for details
MultiplicationTechnique multiplicationTechnique;
// Interactive multi-party bootstrapping parameter
// Set the compression level in ciphertext (SLACK or COMPACT)
// SLACK has weaker security assumption, thus less efficient
// COMPACT has stronger security assumption, thus more efficient
CompressionLevel interactiveBootCompressionLevel;
// CKKS composite scaling parameters to support high-precision CKKS RNS with small word sizes
// Please refer to https://eprint.iacr.org/2023/1462.pdf for details
uint32_t compositeDegree;
uint32_t registerWordSize;
// CKKS data type: real or complex. Noise flooding is only enabled for real values.
CKKSDataType ckksDataType;
void SetToDefaults(SCHEME scheme);
protected:
// How to disable a particular setter for a particular scheme and get an exception thrown if a user tries to call it:
// 1. The set function should be declared virtual in this file
// 2. The same function should be re-defined in the scheme-specific derived file using macros DISABLED_FOR_xxxxRNS defined below.
//
// Example:
// the original setter defined in gen-cryptocontext-params.h:
//
// virtual void SetPlaintextModulus(PlaintextModulus ptModulus0) {
// ptModulus = ptModulus0;
// }
//
// the setter re-defined and disabled in gen-cryptocontext-ckksrns-params.h:
//
// void SetPlaintextModulus(PlaintextModulus ptModulus0) override {
// DISABLED_FOR_CKKS;
// }
#define DISABLED_FOR_CKKSRNS OPENFHE_THROW("This function is not available for CKKSRNS.");
#define DISABLED_FOR_BGVRNS OPENFHE_THROW("This function is not available for BGVRNS.");
#define DISABLED_FOR_BFVRNS OPENFHE_THROW("This function is not available for BFVRNS.");
public:
explicit Params(SCHEME scheme0 = INVALID_SCHEME) {
SetToDefaults(scheme0);
}
explicit Params(const std::vector<std::string>& vals);
Params(const Params& obj) = default;
Params& operator=(const Params& obj) = default;
Params(Params&& obj) noexcept = default;
Params& operator=(Params&& obj) noexcept = default;
virtual ~Params() = default;
static const std::vector<std::string> getAllParamsDataMembers() {
return {"scheme",
"ptModulus",
"digitSize",
"standardDeviation",
"secretKeyDist",
"maxRelinSkDeg",
"ksTech",
"scalTech",
"firstModSize",
"batchSize",
"numLargeDigits",
"multiplicativeDepth",
"scalingModSize",
"securityLevel",
"ringDim",
"evalAddCount",
"keySwitchCount",
"encryptionTechnique",
"multiplicationTechnique",
"PRENumHops",
"PREMode",
"multipartyMode",
"executionMode",
"decryptionNoiseMode",
"noiseEstimate",
"desiredPrecision",
"statisticalSecurity",
"numAdversarialQueries",
"thresholdNumOfParties",
"interactiveBootCompressionLevel",
"compositeDegree",
"registerWordSize",
"ckksDataType"};
}
// getters
SCHEME GetScheme() const {
return scheme;
}
PlaintextModulus GetPlaintextModulus() const {
return ptModulus;
}
uint32_t GetDigitSize() const {
return digitSize;
}
float GetStandardDeviation() const {
return standardDeviation;
}
SecretKeyDist GetSecretKeyDist() const {
return secretKeyDist;
}
uint32_t GetMaxRelinSkDeg() const {
return maxRelinSkDeg;
}
ProxyReEncryptionMode GetPREMode() const {
return PREMode;
}
MultipartyMode GetMultipartyMode() const {
return multipartyMode;
}
ExecutionMode GetExecutionMode() const {
return executionMode;
}
DecryptionNoiseMode GetDecryptionNoiseMode() const {
return decryptionNoiseMode;
}
double GetNoiseEstimate() const {
return noiseEstimate;
}
double GetDesiredPrecision() const {
return desiredPrecision;
}
double GetStatisticalSecurity() const {
return statisticalSecurity;
}
double GetNumAdversarialQueries() const {
return numAdversarialQueries;
}
uint32_t GetThresholdNumOfParties() const {
return thresholdNumOfParties;
}
KeySwitchTechnique GetKeySwitchTechnique() const {
return ksTech;
}
ScalingTechnique GetScalingTechnique() const {
return scalTech;
}
uint32_t GetBatchSize() const {
return batchSize;
}
uint32_t GetFirstModSize() const {
return firstModSize;
}
uint32_t GetNumLargeDigits() const {
return numLargeDigits;
}
uint32_t GetMultiplicativeDepth() const {
return multiplicativeDepth;
}
uint32_t GetScalingModSize() const {
return scalingModSize;
}
SecurityLevel GetSecurityLevel() const {
return securityLevel;
}
uint32_t GetRingDim() const {
return ringDim;
}
uint32_t GetEvalAddCount() const {
return evalAddCount;
}
uint32_t GetKeySwitchCount() const {
return keySwitchCount;
}
EncryptionTechnique GetEncryptionTechnique() const {
return encryptionTechnique;
}
MultiplicationTechnique GetMultiplicationTechnique() const {
return multiplicationTechnique;
}
uint32_t GetPRENumHops() const {
return PRENumHops;
}
CompressionLevel GetInteractiveBootCompressionLevel() const {
return interactiveBootCompressionLevel;
}
uint32_t GetCompositeDegree() const {
return compositeDegree;
}
uint32_t GetRegisterWordSize() const {
return registerWordSize;
}
CKKSDataType GetCKKSDataType() const {
return ckksDataType;
}
// setters
// They all must be virtual, so any of them can be disabled in the derived class
virtual void SetPlaintextModulus(PlaintextModulus ptModulus0) {
ptModulus = ptModulus0;
}
virtual void SetDigitSize(uint32_t digitSize0) {
digitSize = digitSize0;
}
virtual void SetStandardDeviation(float standardDeviation0) {
standardDeviation = standardDeviation0;
}
virtual void SetSecretKeyDist(SecretKeyDist secretKeyDist0) {
secretKeyDist = secretKeyDist0;
}
virtual void SetMaxRelinSkDeg(uint32_t maxRelinSkDeg0) {
maxRelinSkDeg = maxRelinSkDeg0;
}
virtual void SetPREMode(ProxyReEncryptionMode PREMode0) {
PREMode = PREMode0;
}
virtual void SetMultipartyMode(MultipartyMode multipartyMode0) {
multipartyMode = multipartyMode0;
}
virtual void SetExecutionMode(ExecutionMode executionMode0) {
executionMode = executionMode0;
}
virtual void SetDecryptionNoiseMode(DecryptionNoiseMode decryptionNoiseMode0) {
decryptionNoiseMode = decryptionNoiseMode0;
}
virtual void SetNoiseEstimate(double noiseEstimate0) {
noiseEstimate = noiseEstimate0;
}
virtual void SetDesiredPrecision(double desiredPrecision0) {
desiredPrecision = desiredPrecision0;
}
virtual void SetStatisticalSecurity(uint32_t statisticalSecurity0) {
statisticalSecurity = statisticalSecurity0;
}
virtual void SetNumAdversarialQueries(uint32_t numAdversarialQueries0) {
numAdversarialQueries = numAdversarialQueries0;
}
virtual void SetThresholdNumOfParties(uint32_t thresholdNumOfParties0) {
thresholdNumOfParties = thresholdNumOfParties0;
}
virtual void SetKeySwitchTechnique(KeySwitchTechnique ksTech0) {
ksTech = ksTech0;
}
virtual void SetScalingTechnique(ScalingTechnique scalTech0) {
scalTech = scalTech0;
}
virtual void SetBatchSize(uint32_t batchSize0) {
batchSize = batchSize0;
}
virtual void SetFirstModSize(uint32_t firstModSize0) {
firstModSize = firstModSize0;
}
virtual void SetNumLargeDigits(uint32_t numLargeDigits0) {
numLargeDigits = numLargeDigits0;
}
virtual void SetMultiplicativeDepth(uint32_t multiplicativeDepth0) {
multiplicativeDepth = multiplicativeDepth0;
}
virtual void SetScalingModSize(uint32_t scalingModSize0) {
scalingModSize = scalingModSize0;
}
virtual void SetSecurityLevel(SecurityLevel securityLevel0) {
securityLevel = securityLevel0;
}
virtual void SetRingDim(uint32_t ringDim0) {
ringDim = ringDim0;
}
virtual void SetEvalAddCount(uint32_t evalAddCount0) {
evalAddCount = evalAddCount0;
}
virtual void SetKeySwitchCount(uint32_t keySwitchCount0) {
keySwitchCount = keySwitchCount0;
}
virtual void SetEncryptionTechnique(EncryptionTechnique encryptionTechnique0) {
encryptionTechnique = encryptionTechnique0;
}
virtual void SetMultiplicationTechnique(MultiplicationTechnique multiplicationTechnique0) {
multiplicationTechnique = multiplicationTechnique0;
}
virtual void SetPRENumHops(uint32_t PRENumHops0) {
PRENumHops = PRENumHops0;
}
virtual void SetInteractiveBootCompressionLevel(CompressionLevel interactiveBootCompressionLevel0) {
interactiveBootCompressionLevel = interactiveBootCompressionLevel0;
}
virtual void SetCompositeDegree(uint32_t compositeDegree0) {
compositeDegree = compositeDegree0;
}
virtual void SetRegisterWordSize(uint32_t registerWordSize0) {
registerWordSize = registerWordSize0;
}
virtual void SetCKKSDataType(CKKSDataType ckksDataType0) {
ckksDataType = ckksDataType0;
}
friend std::ostream& operator<<(std::ostream& os, const Params& obj);
};
// ====================================================================================================================
} // namespace lbcrypto
#endif // __GEN_CRYPTOCONTEXT_PARAMS_H__